happy-coder 0.1.9 → 0.1.11

package/dist/index.mjs

@@ -1,27 +1,33 @@
 import chalk from 'chalk';
-import { l as logger, d as backoff, R as RawJSONLinesSchema, A as ApiClient, c as configuration, e as encodeBase64, f as encodeBase64Url, g as decodeBase64, h as delay, b as initializeConfiguration, i as initLoggerWithGlobalConfiguration } from './types-fXgEaaqP.mjs';
+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 { randomUUID, randomBytes } from 'node:crypto';
 import { query, AbortError } from '@anthropic-ai/claude-code';
 import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
-import os, { homedir } from 'node:os';
 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 { fileURLToPath, URL as URL$1 } from 'node:url';
-import { watch as watch$1, readFile, mkdir, writeFile } from 'node:fs/promises';
+import { fileURLToPath } from 'node:url';
+import { readFile, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { createServer, request as request$1 } from 'node:http';
+import { createServer, ServerResponse } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
 import * as z from 'zod';
 import { z as z$1 } from 'zod';
-import { request } from 'node:https';
-import net from 'node:net';
+import { spawn as spawn$1, exec, execSync } from 'child_process';
+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 'fs';
-import 'node:events';
-import 'socket.io-client';
+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 'expo-server-sdk';
 
 function formatClaudeMessage(message, onAssistantResult) {
@@ -144,9 +150,13 @@ function printDivider() {
   console.log(chalk.gray("\u2550".repeat(60)));
 }
 
+function getProjectPath(workingDirectory) {
+  const projectId = resolve(workingDirectory).replace(/[\\\/\.:]/g, "-");
+  return join(homedir(), ".claude", "projects", projectId);
+}
+
 function claudeCheckSession(sessionId, path) {
-  const projectName = resolve(path).replace(/\//g, "-");
-  const projectDir = join(homedir(), ".claude", "projects", projectName);
+  const projectDir = getProjectPath(path);
   const sessionFile = join(projectDir, `${sessionId}.jsonl`);
   const sessionExists = existsSync(sessionFile);
   if (!sessionExists) {
@@ -164,11 +174,29 @@ function claudeCheckSession(sessionId, path) {
   return hasGoodMessage;
 }
 
+async function awaitFileExist(file, timeout = 1e4) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    try {
+      await access(file);
+      return true;
+    } catch (e) {
+      await 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,
@@ -178,6 +206,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", () => {
@@ -215,15 +246,11 @@ async function claudeRemote(opts) {
       logger.debug(`[claudeRemote] Received message from SDK: ${message.type}`);
       formatClaudeMessage(message, opts.onAssistantResult);
       if (message.type === "system" && message.subtype === "init") {
-        const projectName = resolve(opts.path).replace(/\//g, "-");
-        const projectDir = join(homedir(), ".claude", "projects", projectName);
-        mkdirSync(projectDir, { recursive: true });
-        const watcher = watch(projectDir).on("change", (_, filename) => {
-          if (filename === `${message.session_id}.jsonl`) {
-            opts.onSessionFound(message.session_id);
-            watcher.close();
-          }
-        });
+        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);
       }
     }
     logger.debug(`[claudeRemote] Finished iterating over response`);
@@ -245,10 +272,9 @@ async function claudeRemote(opts) {
   logger.debug(`[claudeRemote] Function completed`);
 }
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
 async function claudeLocal(opts) {
-  const projectName = resolve(opts.path).replace(/\//g, "-");
-  const projectDir = join(homedir(), ".claude", "projects", projectName);
+  const projectDir = getProjectPath(opts.path);
   mkdirSync(projectDir, { recursive: true });
   const watcher = watch(projectDir);
   let resolvedSessionId = null;
@@ -282,11 +308,19 @@ async function claudeLocal(opts) {
       if (startFrom) {
         args.push("--resume", startFrom);
       }
-      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || resolve(join(__dirname, "..", "scripts", "claudeInteractiveLaunch.cjs"));
+      if (opts.claudeArgs) {
+        args.push(...opts.claudeArgs);
+      }
+      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || resolve(join(__dirname$1, "..", "scripts", "claudeInteractiveLaunch.cjs"));
+      const env = {
+        ...process.env,
+        ...opts.claudeEnvVars
+      };
       const child = 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 = createInterface({
@@ -511,16 +545,44 @@ class InvalidateSync {
   };
 }
 
+function startFileWatcher(file, onFileChange) {
+  const abortController = new AbortController();
+  void (async () => {
+    while (true) {
+      try {
+        logger.debug(`[FILE_WATCHER] Starting watcher for ${file}`);
+        const watcher = watch$1(file, { persistent: true, signal: abortController.signal });
+        for await (const event of watcher) {
+          if (abortController.signal.aborted) {
+            return;
+          }
+          logger.debug(`[FILE_WATCHER] File changed: ${file}`);
+          onFileChange(file);
+        }
+      } catch (e) {
+        if (abortController.signal.aborted) {
+          return;
+        }
+        logger.debug(`[FILE_WATCHER] Watch error: ${e.message}, restarting watcher in a second`);
+        await delay(1e3);
+      }
+    }
+  })();
+  return () => {
+    abortController.abort();
+  };
+}
+
 function createSessionScanner(opts) {
-  const projectName = resolve(opts.workingDirectory).replace(/\//g, "-");
-  const projectDir = join(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 watchers = /* @__PURE__ */ new Map();
   let processedMessages = /* @__PURE__ */ new Set();
   let seenRemoteUserMessageCounters = /* @__PURE__ */ new Map();
   const sync = new InvalidateSync(async () => {
+    logger.debug(`[SESSION_SCANNER] Syncing...`);
     let sessions = [];
     for (let p of pendingSessions) {
       sessions.push(p);
@@ -534,11 +596,15 @@ function createSessionScanner(opts) {
       try {
         file = await readFile(expectedSessionFile, "utf-8");
       } catch (error) {
+        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 = RawJSONLinesSchema.safeParse(message);
           if (!parsed.success) {
@@ -552,15 +618,16 @@ function createSessionScanner(opts) {
           processedMessages.add(key);
           logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
           logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
-          if (parsed.data.type === "user" && typeof parsed.data.message.content === "string") {
+          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);
               continue;
             }
           }
-          opts.onMessage(parsed.data);
+          opts.onMessage(message);
         } catch (e) {
+          logger.debug(`[SESSION_SCANNER] Error processing message: ${e}`);
           continue;
         }
       }
@@ -574,40 +641,37 @@ function createSessionScanner(opts) {
         finishedSessions.add(p);
       }
     }
-    currentSessionWatcherAbortController?.abort();
-    currentSessionWatcherAbortController = new AbortController();
-    void (async () => {
-      if (currentSessionId) {
-        const sessionFile = join(projectDir, `${currentSessionId}.jsonl`);
-        try {
-          for await (const change of watch$1(sessionFile, { persistent: true, signal: currentSessionWatcherAbortController.signal })) {
-            await processSessionFile(currentSessionId);
-          }
-        } catch (error) {
-          if (error.name !== "AbortError") {
-            logger.debug(`[SESSION_SCANNER] Watch error: ${error.message}`);
-          }
-        }
+    for (let p of sessions) {
+      if (!watchers.has(p)) {
+        watchers.set(p, startFileWatcher(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) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is the same as the current session, skipping`);
         return;
       }
       if (finishedSessions.has(sessionId)) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already finished, skipping`);
         return;
       }
       if (pendingSessions.has(sessionId)) {
+        logger.debug(`[SESSION_SCANNER] New session: ${sessionId} is already pending, skipping`);
         return;
       }
       if (currentSessionId) {
@@ -652,7 +716,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;
@@ -676,23 +740,38 @@ 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();
         }
       });
       onMessage = () => {
         if (!interactiveAbortController.signal.aborted) {
           abortedOutside = true;
-          mode = "remote";
+          if (mode !== "remote") {
+            mode = "remote";
+            if (opts.onModeChange) {
+              opts.onModeChange(mode);
+            }
+          }
           interactiveAbortController.abort();
         }
         onMessage = null;
@@ -701,13 +780,15 @@ async function loop(opts) {
         path: opts.path,
         sessionId,
         onSessionFound,
-        abort: interactiveAbortController.signal
+        abort: interactiveAbortController.signal,
+        claudeEnvVars: opts.claudeEnvVars,
+        claudeArgs: opts.claudeArgs
       });
       onMessage = null;
       if (!abortedOutside) {
         return;
       }
-      if (mode !== "interactive") {
+      if (mode !== "local") {
         console.log("Switching to remote mode...");
       }
     }
@@ -721,7 +802,12 @@ async function loop(opts) {
       });
       const abortHandler = () => {
         if (!remoteAbortController.signal.aborted) {
-          mode = "interactive";
+          if (mode !== "local") {
+            mode = "local";
+            if (opts.onModeChange) {
+              opts.onModeChange(mode);
+            }
+          }
           remoteAbortController.abort();
         }
         if (process.stdin.isTTY) {
@@ -745,7 +831,9 @@ async function loop(opts) {
           onSessionFound,
           messages: currentMessageQueue,
           onAssistantResult: opts.onAssistantResult,
-          interruptController: opts.interruptController
+          interruptController: opts.interruptController,
+          claudeEnvVars: opts.claudeEnvVars,
+          claudeArgs: opts.claudeArgs
         });
       } finally {
         process.stdin.off("data", abortHandler);
@@ -862,155 +950,375 @@ class InterruptController {
   }
 }
 
-var version = "0.1.9";
+var version = "0.1.11";
 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);
-      logger.debug(`[AnthropicProxy #${requestId}] Cleaned up (${reason}), active requests: ${requestTimeouts.size}`);
-      claudeDidSomeWork();
-    }
-  };
-  const claudeDidSomeWork = () => {
-    if (idleTimer) clearTimeout(idleTimer);
-    if (requestTimeouts.size === 0) {
-      idleTimer = setTimeout(() => {
-        logger.debug(`[AnthropicProxy] Idle for ${maxTimeBeforeIdle}ms, active requests: ${requestTimeouts.size}`);
-        onClaudeActivity("idle");
-      }, maxTimeBeforeIdle);
-    }
-  };
-  const server = createServer((req, res) => {
-    const requestId = ++requestCounter;
-    const isAnthropicRequest = req.headers.host === "api.anthropic.com" || req.url?.includes("anthropic.com");
-    if (isAnthropicRequest) {
-      const timeout = setTimeout(() => {
-        logger.debug(`[AnthropicProxy #${requestId}] Request timeout after ${requestTimeout}ms`);
-        cleanupRequest(requestId, "timeout");
-      }, requestTimeout);
-      requestTimeouts.set(requestId, timeout);
-      onClaudeActivity("working");
-      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 = dirname$1(fileURLToPath$1(import.meta.url));
+const RUNNER_PATH = join$1(__dirname, "..", "..", "scripts", "ripgrep_launcher.cjs");
+function run(args, options) {
+  return new Promise((resolve, reject) => {
+    const child = spawn$1("node", [RUNNER_PATH, JSON.stringify(args)], {
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd: options?.cwd
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code || 0,
+        stdout,
+        stderr
+      });
+    });
+    child.on("error", (err) => {
+      reject(err);
     });
-    req.on("end", () => {
-      const body = Buffer.concat(chunks);
-      let targetUrl;
-      if (isAnthropicRequest) {
-        targetUrl = new URL$1(req.url || "/", "https://api.anthropic.com");
+  });
+}
+
+const execAsync = promisify(exec);
+function registerHandlers(session, interruptController, permissionCallbacks, onSwitchRemoteRequested) {
+  session.setHandler("abort", async () => {
+    logger.info("Abort request - interrupting Claude");
+    await interruptController.interrupt();
+  });
+  if (permissionCallbacks) {
+    session.setHandler("permission", async (message) => {
+      logger.info("Permission response" + JSON.stringify(message));
+      const id = message.id;
+      const resolve = permissionCallbacks.requests.get(id);
+      if (resolve) {
+        if (!message.approved) {
+          logger.debug("Permission denied, interrupting Claude");
+          await interruptController.interrupt();
+        }
+        resolve({ approved: message.approved, reason: message.reason });
+        permissionCallbacks.requests.delete(id);
       } else {
-        const protocol = req.headers["x-forwarded-proto"] || "https";
-        const host = req.headers.host || "localhost";
-        targetUrl = new URL$1(req.url || "/", `${protocol}://${host}`);
+        logger.info("Permission request stale, likely timed out");
+        return;
       }
+      session.updateAgentState((currentState) => {
+        let r = { ...currentState.requests };
+        delete r[id];
+        return {
+          ...currentState,
+          requests: r
+        };
+      });
+    });
+  }
+  session.setHandler("bash", async (data) => {
+    logger.info("Shell command request:", data.command);
+    try {
       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
-        }
+        cwd: data.cwd,
+        timeout: data.timeout || 3e4
+        // Default 30 seconds timeout
       };
-      const requestMethod = targetUrl.protocol === "https:" ? request : request$1;
-      const proxyReq = requestMethod(options, (proxyRes) => {
-        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-        proxyRes.pipe(res);
-        proxyRes.on("end", () => {
-          if (isAnthropicRequest) {
-            cleanupRequest(requestId, "completed");
+      const { stdout, stderr } = await execAsync(data.command, options);
+      return {
+        success: true,
+        stdout: stdout || "",
+        stderr: stderr || "",
+        exitCode: 0
+      };
+    } catch (error) {
+      const execError = error;
+      if (execError.code === "ETIMEDOUT" || execError.killed) {
+        return {
+          success: false,
+          stdout: execError.stdout || "",
+          stderr: execError.stderr || "",
+          exitCode: typeof execError.code === "number" ? execError.code : -1,
+          error: "Command timed out"
+        };
+      }
+      return {
+        success: false,
+        stdout: execError.stdout || "",
+        stderr: execError.stderr || execError.message || "Command failed",
+        exitCode: typeof execError.code === "number" ? execError.code : 1,
+        error: execError.message || "Command failed"
+      };
+    }
+  });
+  session.setHandler("readFile", async (data) => {
+    logger.info("Read file request:", data.path);
+    try {
+      const buffer = await readFile$1(data.path);
+      const content = buffer.toString("base64");
+      return { success: true, content };
+    } catch (error) {
+      logger.debug("Failed to read file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
+    }
+  });
+  session.setHandler("writeFile", async (data) => {
+    logger.info("Write file request:", data.path);
+    try {
+      if (data.expectedHash !== null && data.expectedHash !== void 0) {
+        try {
+          const existingBuffer = await readFile$1(data.path);
+          const existingHash = createHash("sha256").update(existingBuffer).digest("hex");
+          if (existingHash !== data.expectedHash) {
+            return {
+              success: false,
+              error: `File hash mismatch. Expected: ${data.expectedHash}, Actual: ${existingHash}`
+            };
+          }
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+          return {
+            success: false,
+            error: "File does not exist but hash was provided"
+          };
+        }
+      } else {
+        try {
+          await stat(data.path);
+          return {
+            success: false,
+            error: "File already exists but was expected to be new"
+          };
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
           }
-        });
-      });
-      proxyReq.on("error", (error) => {
-        if (isAnthropicRequest) {
-          cleanupRequest(requestId, `error: ${error.message}`);
-        } else {
-          logger.debug(`[AnthropicProxy #${requestId}] Error:`, error.message);
         }
-        res.writeHead(502);
-        res.end("Bad Gateway");
-      });
-      if (body.length > 0) {
-        proxyReq.write(body);
       }
-      proxyReq.end();
-    });
+      const buffer = Buffer.from(data.content, "base64");
+      await writeFile(data.path, buffer);
+      const hash = createHash("sha256").update(buffer).digest("hex");
+      return { success: true, hash };
+    } catch (error) {
+      logger.debug("Failed to write file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
+    }
   });
-  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(() => {
-        logger.debug(`[AnthropicProxy #${requestId}] CONNECT timeout after ${requestTimeout}ms`);
-        cleanupRequest(requestId, "timeout");
-      }, requestTimeout);
-      requestTimeouts.set(requestId, timeout);
-      onClaudeActivity("working");
-      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);
-    });
-    const cleanup = () => {
-      if (isAnthropicRequest) {
-        cleanupRequest(requestId, "CONNECT closed");
+  session.setHandler("listDirectory", async (data) => {
+    logger.info("List directory request:", data.path);
+    try {
+      const entries = await readdir(data.path, { withFileTypes: true });
+      const directoryEntries = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = join$1(data.path, entry.name);
+          let type = "other";
+          let size;
+          let modified;
+          if (entry.isDirectory()) {
+            type = "directory";
+          } else if (entry.isFile()) {
+            type = "file";
+          }
+          try {
+            const stats = await stat(fullPath);
+            size = stats.size;
+            modified = stats.mtime.getTime();
+          } catch (error) {
+            logger.debug(`Failed to stat ${fullPath}:`, error);
+          }
+          return {
+            name: entry.name,
+            type,
+            size,
+            modified
+          };
+        })
+      );
+      directoryEntries.sort((a, b) => {
+        if (a.type === "directory" && b.type !== "directory") return -1;
+        if (a.type !== "directory" && b.type === "directory") return 1;
+        return a.name.localeCompare(b.name);
+      });
+      return { success: true, entries: directoryEntries };
+    } catch (error) {
+      logger.debug("Failed to list directory:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
+    }
+  });
+  session.setHandler("getDirectoryTree", async (data) => {
+    logger.info("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    async function buildTree(path, name, currentDepth) {
+      try {
+        const stats = await stat(path);
+        const node = {
+          name,
+          path,
+          type: stats.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.getTime()
+        };
+        if (stats.isDirectory() && currentDepth < data.maxDepth) {
+          const entries = await readdir(path, { withFileTypes: true });
+          const children = [];
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (entry.isSymbolicLink()) {
+                logger.debug(`Skipping symlink: ${join$1(path, entry.name)}`);
+                return;
+              }
+              const childPath = join$1(path, entry.name);
+              const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
+              if (childNode) {
+                children.push(childNode);
+              }
+            })
+          );
+          children.sort((a, b) => {
+            if (a.type === "directory" && b.type !== "directory") return -1;
+            if (a.type !== "directory" && b.type === "directory") return 1;
+            return a.name.localeCompare(b.name);
+          });
+          node.children = children;
+        }
+        return node;
+      } catch (error) {
+        logger.debug(`Failed to process ${path}:`, error instanceof Error ? error.message : String(error));
+        return null;
       }
-    };
-    serverSocket.on("error", (err) => {
-      logger.debug(`[AnthropicProxy #${requestId}] CONNECT error:`, err.message);
-      clientSocket.end();
-      cleanup();
-    });
-    clientSocket.on("error", cleanup);
-    clientSocket.on("end", cleanup);
-    serverSocket.on("end", cleanup);
+    }
+    try {
+      if (data.maxDepth < 0) {
+        return { success: false, error: "maxDepth must be non-negative" };
+      }
+      const baseName = data.path === "/" ? "/" : data.path.split("/").pop() || data.path;
+      const tree = await buildTree(data.path, baseName, 0);
+      if (!tree) {
+        return { success: false, error: "Failed to access the specified path" };
+      }
+      return { success: true, tree };
+    } catch (error) {
+      logger.debug("Failed to get directory tree:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
+    }
+  });
+  session.setHandler("ripgrep", async (data) => {
+    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) {
+      logger.debug("Failed to run ripgrep:", error);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Failed to run ripgrep"
+      };
+    }
   });
-  const url = await new Promise((resolve) => {
+}
+
+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") {
-        resolve(`http://127.0.0.1:${addr.port}`);
+        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"));
       }
     });
   });
-  logger.debug(`[AnthropicProxy] Started at ${url}`);
-  return {
-    url,
-    cleanup: () => {
-      if (idleTimer) clearTimeout(idleTimer);
-      for (const [requestId, timeout] of requestTimeouts) {
-        clearTimeout(timeout);
-        logger.debug(`[AnthropicProxy] Cleaning up timeout for request #${requestId}`);
+  return url;
+}
+
+async function startClaudeActivityTracker(onThinking) {
+  let requestCounter = 0;
+  const activeRequests = /* @__PURE__ */ new Set();
+  let stopThinkingTimeout = null;
+  let isThinking = false;
+  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;
+        activeRequests.add(requestId);
+        req._requestId = requestId;
+        if (stopThinkingTimeout) {
+          clearTimeout(stopThinkingTimeout);
+          stopThinkingTimeout = null;
+        }
+        if (!isThinking) {
+          logger.debug(`[ClaudeActivityTracker] Thinking started`);
+          isThinking = true;
+          onThinking(true);
+        }
       }
-      requestTimeouts.clear();
-      if (requestTimeouts.size > 0) {
-        logger.debug(`[AnthropicProxy] Warning: ${requestTimeouts.size} active requests still pending at cleanup:`, Array.from(requestTimeouts.keys()));
+    },
+    onResponse: (req, proxyRes) => {
+      if (req.method === "POST" && req.url?.startsWith("/v1/messages")) {
+        const requestId = req._requestId;
+        proxyRes.on("end", () => {
+          activeRequests.delete(requestId);
+          if (activeRequests.size === 0 && isThinking && !stopThinkingTimeout) {
+            stopThinkingTimeout = setTimeout(() => {
+              if (isThinking) {
+                isThinking = false;
+                logger.debug(`[ClaudeActivityTracker] Thinking stopped`);
+                onThinking(false);
+              }
+            }, 500);
+          }
+        });
+        proxyRes.on("error", () => {
+          activeRequests.delete(requestId);
+          if (activeRequests.size === 0 && isThinking && !stopThinkingTimeout) {
+            stopThinkingTimeout = setTimeout(() => {
+              if (isThinking) {
+                isThinking = false;
+                logger.debug(`[ClaudeActivityTracker] Thinking stopped`);
+                onThinking(false);
+              }
+            }, 500);
+          }
+        });
       }
-      server.close();
     }
-  };
+  });
+  return proxyUrl;
 }
 
 async function start(credentials, options = {}) {
@@ -1018,30 +1326,23 @@ async function start(credentials, options = {}) {
   const sessionTag = randomUUID();
   const api = new ApiClient(credentials.token, credentials.secret);
   let state = {};
-  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version };
+  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version, os: os.platform() };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   logger.debug(`Session created: ${response.id}`);
   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;
-        logger.debug(`[PING] Thinking state changed: ${thinking}`);
-        session.keepAlive(thinking);
-      }
-    }
-  );
-  process.env.HTTP_PROXY = antropicActivityProxy.url;
-  process.env.HTTPS_PROXY = antropicActivityProxy.url;
-  logger.debug(`[AnthropicProxy] Set HTTP_PROXY and HTTPS_PROXY to ${antropicActivityProxy.url}`);
+  const proxyUrl = await startClaudeActivityTracker((newThinking) => {
+    thinking = newThinking;
+    session.keepAlive(thinking, mode);
+  });
+  process.env.ANTHROPIC_BASE_URL = proxyUrl;
   const logPath = await logger.logFilePathPromise;
-  logger.info(`Session: ${response.id}`);
+  logger.infoDeveloper(`Session: ${response.id}`);
   logger.infoDeveloper(`Logs: ${logPath}`);
   const interruptController = new InterruptController();
   let requests = /* @__PURE__ */ new Map();
@@ -1051,10 +1352,10 @@ async function start(credentials, options = {}) {
       requests.set(id, resolve);
     });
     let timeout = setTimeout(async () => {
-      logger.info("Permission timeout - attempting to interrupt Claude");
+      logger.debug("Permission timeout - attempting to interrupt Claude");
       const interrupted = await interruptController.interrupt();
       if (interrupted) {
-        logger.info("Claude interrupted successfully");
+        logger.debug("Claude interrupted successfully");
       }
       requests.delete(id);
       session.updateAgentState((currentState) => {
@@ -1066,7 +1367,7 @@ async function start(credentials, options = {}) {
         };
       });
     }, 1e3 * 60 * 4.5);
-    logger.info("Permission request" + id + " " + JSON.stringify(request));
+    logger.debug("Permission request" + id + " " + JSON.stringify(request));
     try {
       await pushClient.sendToAllDevices(
         "Permission Request",
@@ -1078,7 +1379,7 @@ async function start(credentials, options = {}) {
           type: "permission_request"
         }
       );
-      logger.info("Push notification sent for permission request");
+      logger.debug("Push notification sent for permission request");
     } catch (error) {
       logger.debug("Failed to send push notification:", error);
     }
@@ -1095,29 +1396,7 @@ async function start(credentials, options = {}) {
     promise.then(() => clearTimeout(timeout)).catch(() => clearTimeout(timeout));
     return promise;
   });
-  session.setHandler("permission", (message) => {
-    logger.info("Permission response" + JSON.stringify(message));
-    const id = message.id;
-    const resolve = requests.get(id);
-    if (resolve) {
-      resolve({ approved: message.approved, reason: message.reason });
-    } else {
-      logger.info("Permission request stale, likely timed out");
-      return;
-    }
-    session.updateAgentState((currentState) => {
-      let r = { ...currentState.requests };
-      delete r[id];
-      return {
-        ...currentState,
-        requests: r
-      };
-    });
-  });
-  session.setHandler("abort", async () => {
-    logger.info("Abort request - interrupting Claude");
-    await interruptController.interrupt();
-  });
+  registerHandlers(session, interruptController, { requests });
   const onAssistantResult = async (result) => {
     try {
       const summary = "result" in result && result.result ? result.result.substring(0, 100) + (result.result.length > 100 ? "..." : "") : "";
@@ -1142,6 +1421,15 @@ 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);
+      session.updateAgentState((currentState) => ({
+        ...currentState,
+        controlledByUser: newMode === "local" ? true : false
+      }));
+    },
     mcpServers: {
       "permission": {
         type: "http",
@@ -1151,16 +1439,34 @@ async function start(credentials, options = {}) {
     permissionPromptToolName: "mcp__permission__" + permissionServer.toolName,
     session,
     onAssistantResult,
-    interruptController
+    interruptController,
+    claudeEnvVars: options.claudeEnvVars,
+    claudeArgs: options.claudeArgs
   });
   clearInterval(pingInterval);
-  if (antropicActivityProxy) {
-    logger.info("[AnthropicProxy] Shutting down activity monitoring proxy");
-    antropicActivityProxy.cleanup();
-  }
   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()
@@ -1184,7 +1490,7 @@ async function writeCredentials(credentials) {
   if (!existsSync(configuration.happyDir)) {
     await mkdir(configuration.happyDir, { recursive: true });
   }
-  await writeFile(configuration.privateKeyFile, JSON.stringify({
+  await writeFile$1(configuration.privateKeyFile, JSON.stringify({
     secret: encodeBase64(credentials.secret),
     token: credentials.token
   }, null, 2));
@@ -1262,6 +1568,413 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
   return decrypted;
 }
 
+class ApiDaemonSession extends EventEmitter {
+  socket;
+  machineIdentity;
+  keepAliveInterval = null;
+  token;
+  secret;
+  constructor(token, secret, machineIdentity) {
+    super();
+    this.token = token;
+    this.secret = secret;
+    this.machineIdentity = machineIdentity;
+    const socket = io(configuration.serverUrl, {
+      auth: {
+        token: this.token,
+        clientType: "machine-scoped",
+        machineId: this.machineIdentity.machineId
+      },
+      path: "/v1/user-machine-daemon",
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      transports: ["websocket"],
+      withCredentials: true,
+      autoConnect: false
+    });
+    socket.on("connect", () => {
+      logger.debug("[DAEMON] Connected to server");
+      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, {
+            detached: true,
+            stdio: "ignore",
+            cwd: requestData.directory
+          });
+          child.unref();
+        }
+        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)));
+      }
+    });
+    socket.on("daemon-command", (data) => {
+      switch (data.command) {
+        case "shutdown":
+          this.shutdown();
+          break;
+        case "status":
+          this.emit("status-request");
+          break;
+      }
+    });
+    this.socket = socket;
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveInterval = setInterval(() => {
+      this.socket.volatile.emit("machine-alive", {
+        time: Date.now()
+      });
+    }, 2e4);
+  }
+  stopKeepAlive() {
+    if (this.keepAliveInterval) {
+      clearInterval(this.keepAliveInterval);
+      this.keepAliveInterval = null;
+    }
+  }
+  connect() {
+    this.socket.connect();
+  }
+  shutdown() {
+    this.stopKeepAlive();
+    this.socket.close();
+    this.emit("shutdown");
+  }
+}
+
+async function startDaemon() {
+  console.log("[DAEMON] Starting daemon process...");
+  if (await isDaemonRunning()) {
+    console.log("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");
+  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) {
+      settings.machineId = crypto.randomUUID();
+      settings.machineHost = hostname();
+      await writeSettings(settings);
+    }
+    const machineIdentity = {
+      machineId: settings.machineId,
+      machineHost: settings.machineHost || hostname(),
+      platform: process.platform,
+      version: process.env.npm_package_version || "unknown"
+    };
+    let credentials = await readCredentials();
+    if (!credentials) {
+      logger.debug("[DAEMON] No credentials found, running auth");
+      await doAuth();
+      credentials = await readCredentials();
+      if (!credentials) {
+        throw new Error("Failed to authenticate");
+      }
+    }
+    const { token, secret } = credentials;
+    const daemon = new ApiDaemonSession(token, secret, machineIdentity);
+    daemon.on("connected", () => {
+      logger.debug("[DAEMON] Successfully connected to server");
+    });
+    daemon.on("disconnected", () => {
+      logger.debug("[DAEMON] Disconnected from server");
+    });
+    daemon.on("shutdown", () => {
+      logger.debug("[DAEMON] Shutdown requested");
+      stopDaemon();
+      process.exit(0);
+    });
+    daemon.connect();
+    setInterval(() => {
+    }, 1e3);
+  } catch (error) {
+    logger.debug("[DAEMON] 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...");
+    if (existsSync$1(configuration.daemonPidFile)) {
+      console.log("[isDaemonRunning] PID file exists");
+      const pid = parseInt(readFileSync$1(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");
+          logger.debug(`[DAEMON] 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");
+        unlinkSync(configuration.daemonPidFile);
+      }
+    } else {
+      console.log("[isDaemonRunning] No PID file found");
+    }
+    return false;
+  } catch (error) {
+    console.log("[isDaemonRunning] Error:", error);
+    logger.debug("[DAEMON] Error checking daemon status", error);
+    return false;
+  }
+}
+function writePidFile() {
+  const happyDir = join$1(homedir$1(), ".happy");
+  if (!existsSync$1(happyDir)) {
+    mkdirSync$1(happyDir, { recursive: true });
+  }
+  try {
+    writeFileSync(configuration.daemonPidFile, process.pid.toString(), { flag: "wx" });
+  } 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");
+    }
+    throw error;
+  }
+}
+async function stopDaemon() {
+  try {
+    if (existsSync$1(configuration.daemonPidFile)) {
+      const pid = parseInt(readFileSync$1(configuration.daemonPidFile, "utf-8"));
+      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) {
+        logger.debug("[DAEMON] Process already dead or inaccessible", error);
+      }
+      unlinkSync(configuration.daemonPidFile);
+    }
+  } catch (error) {
+    logger.debug("[DAEMON] Error stopping daemon", error);
+  }
+}
+async function isProcessHappyDaemon(pid) {
+  return new Promise((resolve) => {
+    const ps = spawn$1("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");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  const minSpaces = lines.reduce((min, line) => {
+    if (line.trim() === "") {
+      return min;
+    }
+    const leadingSpaces = line.match(/^\s*/)[0].length;
+    return Math.min(min, leadingSpaces);
+  }, Infinity);
+  const trimmedLines = lines.map((line) => line.slice(minSpaces));
+  return trimmedLines.join("\n");
+}
+
+const PLIST_LABEL$1 = "com.happy-cli.daemon";
+const PLIST_FILE$1 = `/Library/LaunchDaemons/${PLIST_LABEL$1}.plist`;
+const USER_HOME = process.env.HOME || process.env.USERPROFILE;
+async function install$1() {
+  try {
+    if (existsSync$1(PLIST_FILE$1)) {
+      logger.info("Daemon plist already exists. Uninstalling first...");
+      execSync(`launchctl unload ${PLIST_FILE$1}`, { stdio: "inherit" });
+    }
+    const happyPath = process.argv[0];
+    const scriptPath = process.argv[1];
+    const plistContent = trimIdent(`
+            <?xml version="1.0" encoding="UTF-8"?>
+            <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+            <plist version="1.0">
+            <dict>
+                <key>Label</key>
+                <string>${PLIST_LABEL$1}</string>
+                
+                <key>ProgramArguments</key>
+                <array>
+                    <string>${happyPath}</string>
+                    <string>${scriptPath}</string>
+                    <string>happy-daemon</string>
+                </array>
+                
+                <key>EnvironmentVariables</key>
+                <dict>
+                    <key>HAPPY_DAEMON_MODE</key>
+                    <string>true</string>
+                </dict>
+                
+                <key>RunAtLoad</key>
+                <true/>
+                
+                <key>KeepAlive</key>
+                <true/>
+                
+                <key>StandardErrorPath</key>
+                <string>${USER_HOME}/.happy/daemon.err</string>
+                
+                <key>StandardOutPath</key>
+                <string>${USER_HOME}/.happy/daemon.log</string>
+                
+                <key>WorkingDirectory</key>
+                <string>/tmp</string>
+            </dict>
+            </plist>
+        `);
+    writeFileSync(PLIST_FILE$1, plistContent);
+    chmodSync(PLIST_FILE$1, 420);
+    logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
+    execSync(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
+    logger.info("Daemon installed and started successfully");
+    logger.info("Check logs at ~/.happy/daemon.log");
+  } catch (error) {
+    logger.debug("Failed to install daemon:", error);
+    throw error;
+  }
+}
+
+async function install() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon installation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon installation requires sudo privileges. Please run with sudo.");
+  }
+  logger.info("Installing Happy CLI daemon for macOS...");
+  await install$1();
+}
+
+const PLIST_LABEL = "com.happy-cli.daemon";
+const PLIST_FILE = `/Library/LaunchDaemons/${PLIST_LABEL}.plist`;
+async function uninstall$1() {
+  try {
+    if (!existsSync$1(PLIST_FILE)) {
+      logger.info("Daemon plist not found. Nothing to uninstall.");
+      return;
+    }
+    try {
+      execSync(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
+      logger.info("Daemon stopped successfully");
+    } catch (error) {
+      logger.info("Failed to unload daemon (it might not be running)");
+    }
+    unlinkSync(PLIST_FILE);
+    logger.info(`Removed daemon plist from ${PLIST_FILE}`);
+    logger.info("Daemon uninstalled successfully");
+  } catch (error) {
+    logger.debug("Failed to uninstall daemon:", error);
+    throw error;
+  }
+}
+
+async function uninstall() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon uninstallation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon uninstallation requires sudo privileges. Please run with sudo.");
+  }
+  logger.info("Uninstalling Happy CLI daemon for macOS...");
+  await uninstall$1();
+}
+
 (async () => {
   const args = process.argv.slice(2);
   let installationLocation = args.includes("--local") || process.env.HANDY_LOCAL ? "local" : "global";
@@ -1281,39 +1994,40 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
     }
     return;
   } else if (subcommand === "daemon") {
-    if (process.env.HAPPY_DAEMON_MODE) {
-      const { run } = await import('./run-FBXkmmN7.mjs');
-      await run();
+    const daemonSubcommand = args[1];
+    if (daemonSubcommand === "start") {
+      await startDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "stop") {
+      await stopDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "install") {
+      try {
+        await install();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else if (daemonSubcommand === "uninstall") {
+      try {
+        await uninstall();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
     } else {
-      const daemonSubcommand = args[1];
-      if (daemonSubcommand === "install") {
-        const { install } = await import('./install-HKe7dyS4.mjs');
-        try {
-          await install();
-        } catch (error) {
-          console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-          process.exit(1);
-        }
-      } else if (daemonSubcommand === "uninstall") {
-        const { uninstall } = await import('./uninstall-CLkTtlMv.mjs');
-        try {
-          await uninstall();
-        } catch (error) {
-          console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-          process.exit(1);
-        }
-      } else {
-        console.log(`
+      console.log(`
 ${chalk.bold("happy daemon")} - Daemon management
 
 ${chalk.bold("Usage:")}
+  happy daemon start            Start the daemon
+  happy daemon stop             Stop the daemon
   sudo happy daemon install     Install the daemon (requires sudo)
   sudo happy daemon uninstall   Uninstall the daemon (requires sudo)
 
 ${chalk.bold("Note:")} The daemon runs in the background and provides persistent services.
 Currently only supported on macOS.
 `);
-      }
     }
     return;
   } else {
@@ -1336,7 +2050,18 @@ Currently only supported on macOS.
       } else if (arg === "--local") {
         i++;
       } else if (arg === "--happy-starting-mode") {
-        options.startingMode = z$1.enum(["interactive", "remote"]).parse(args[++i]);
+        options.startingMode = z$1.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);
@@ -1357,20 +2082,31 @@ ${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 >
       Will use .happy folder in the current directory for storing your private key and debug logs. 
       You will require re-login each time you run this in a new directory.
-
-  --happy-starting-mode <mode>  Start in specified mode (interactive or remote) 
-      Default: interactive
+  --happy-starting-mode <interactive|remote>
+      Set the starting mode for new sessions (default: remote)
 
 ${chalk.bold("Examples:")}
   happy                   Start a session with default settings
   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);
@@ -1387,6 +2123,7 @@ ${chalk.bold("Examples:")}
       }
       credentials = res;
     }
+    await readSettings() || { };
     try {
       await start(credentials, options);
     } catch (error) {