happy-coder 0.1.12 → 0.1.14

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var chalk = require('chalk');
-var types = require('./types-hotUTaWz.cjs');
+var types = require('./types-Cg4664gs.cjs');
 var node_crypto = require('node:crypto');
 var claudeCode = require('@anthropic-ai/claude-code');
 var node_fs = require('node:fs');
@@ -21,7 +21,6 @@ var util = require('util');
 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');
@@ -261,18 +260,32 @@ async function claudeRemote(opts) {
     });
   }
   printDivider();
+  let thinking = false;
+  const updateThinking = (newThinking) => {
+    if (thinking !== newThinking) {
+      thinking = newThinking;
+      types.logger.debug(`[claudeRemote] Thinking state changed to: ${thinking}`);
+      if (opts.onThinkingChange) {
+        opts.onThinkingChange(thinking);
+      }
+    }
+  };
   try {
     types.logger.debug(`[claudeRemote] Starting to iterate over response`);
     for await (const message of response) {
       types.logger.debugLargeJson(`[claudeRemote] Message ${message.type}`, message);
       formatClaudeMessage(message, opts.onAssistantResult);
       if (message.type === "system" && message.subtype === "init") {
+        updateThinking(true);
         types.logger.debug(`[claudeRemote] Waiting for session file to be written to disk: ${message.session_id}`);
         const projectDir = getProjectPath(opts.path);
         const found = await awaitFileExist(node_path.join(projectDir, `${message.session_id}.jsonl`));
         types.logger.debug(`[claudeRemote] Session file found: ${message.session_id} ${found}`);
         opts.onSessionFound(message.session_id);
       }
+      if (message.type === "result") {
+        updateThinking(false);
+      }
     }
     types.logger.debug(`[claudeRemote] Finished iterating over response`);
   } catch (e) {
@@ -285,6 +298,7 @@ async function claudeRemote(opts) {
       throw e;
     }
   } finally {
+    updateThinking(false);
     if (opts.interruptController) {
       opts.interruptController.unregister();
     }
@@ -348,22 +362,70 @@ async function claudeLocal(opts) {
           input: child.stdio[3],
           crlfDelay: Infinity
         });
-        rl.on("line", (line) => {
-          const sessionMatch = line.match(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i);
-          if (sessionMatch) {
-            detectedIdsRandomUUID.add(sessionMatch[0]);
-            if (resolvedSessionId) {
-              return;
+        const activeFetches = /* @__PURE__ */ new Map();
+        let thinking = false;
+        let stopThinkingTimeout = null;
+        const updateThinking = (newThinking) => {
+          if (thinking !== newThinking) {
+            thinking = newThinking;
+            types.logger.debug(`[ClaudeLocal] Thinking state changed to: ${thinking}`);
+            if (opts.onThinkingChange) {
+              opts.onThinkingChange(thinking);
             }
-            if (detectedIdsFileSystem.has(sessionMatch[0])) {
-              resolvedSessionId = sessionMatch[0];
-              opts.onSessionFound(sessionMatch[0]);
+          }
+        };
+        rl.on("line", (line) => {
+          try {
+            const message = JSON.parse(line);
+            switch (message.type) {
+              case "uuid":
+                detectedIdsRandomUUID.add(message.value);
+                if (!resolvedSessionId && detectedIdsFileSystem.has(message.value)) {
+                  resolvedSessionId = message.value;
+                  opts.onSessionFound(message.value);
+                }
+                break;
+              case "fetch-start":
+                types.logger.debug(`[ClaudeLocal] Fetch start: ${message.method} ${message.hostname}${message.path} (id: ${message.id})`);
+                activeFetches.set(message.id, {
+                  hostname: message.hostname,
+                  path: message.path,
+                  startTime: message.timestamp
+                });
+                if (stopThinkingTimeout) {
+                  clearTimeout(stopThinkingTimeout);
+                  stopThinkingTimeout = null;
+                }
+                updateThinking(true);
+                break;
+              case "fetch-end":
+                types.logger.debug(`[ClaudeLocal] Fetch end: id ${message.id}`);
+                activeFetches.delete(message.id);
+                if (activeFetches.size === 0 && thinking && !stopThinkingTimeout) {
+                  stopThinkingTimeout = setTimeout(() => {
+                    if (activeFetches.size === 0) {
+                      updateThinking(false);
+                    }
+                    stopThinkingTimeout = null;
+                  }, 500);
+                }
+                break;
+              default:
+                types.logger.debug(`[ClaudeLocal] Unknown message type: ${message.type}`);
             }
+          } catch (e) {
+            types.logger.debug(`[ClaudeLocal] Non-JSON line from fd3: ${line}`);
           }
         });
         rl.on("error", (err) => {
           console.error("Error reading from fd 3:", err);
         });
+        child.on("exit", () => {
+          if (stopThinkingTimeout) {
+            clearTimeout(stopThinkingTimeout);
+          }
+          updateThinking(false);
+        });
       }
       child.on("error", (error) => {
       });
@@ -819,6 +881,7 @@ async function loop(opts) {
           path: opts.path,
           sessionId,
           onSessionFound,
+          onThinkingChange: opts.onThinkingChange,
           abort: interactiveAbortController.signal,
           claudeEnvVars: opts.claudeEnvVars,
           claudeArgs: opts.claudeArgs
@@ -881,6 +944,7 @@ async function loop(opts) {
           mcpServers: opts.mcpServers,
           permissionPromptToolName: opts.permissionPromptToolName,
           onSessionFound,
+          onThinkingChange: opts.onThinkingChange,
           messages: currentMessageQueue,
           onAssistantResult: opts.onAssistantResult,
           interruptController: opts.interruptController,
@@ -1009,7 +1073,7 @@ class InterruptController {
   }
 }
 
-var version = "0.1.12";
+var version = "0.1.14";
 var packageJson = {
 	version: version};
 
@@ -1294,148 +1358,77 @@ function registerHandlers(session, interruptController, permissionCallbacks, onS
   });
 }
 
-async function startHTTPDirectProxy(options) {
-  const proxy = httpProxy.createProxyServer({
-    target: options.target,
-    changeOrigin: true,
-    secure: false
-  });
-  proxy.on("error", (err, req, res) => {
-    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;
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!node_fs.existsSync(types.configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await promises$1.readFile(types.configuration.settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
 }
-
-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 writeSettings(settings) {
+  if (!node_fs.existsSync(types.configuration.happyDir)) {
+    await promises$1.mkdir(types.configuration.happyDir, { recursive: true });
+  }
+  await promises$1.writeFile(types.configuration.settingsFile, JSON.stringify(settings, null, 2));
+}
+const credentialsSchema = z__namespace.object({
+  secret: z__namespace.string().base64(),
+  token: z__namespace.string()
+});
+async function readCredentials() {
+  if (!node_fs.existsSync(types.configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    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")),
+      token: credentials.token
+    };
+  } catch {
+    return null;
+  }
+}
+async function writeCredentials(credentials) {
+  if (!node_fs.existsSync(types.configuration.happyDir)) {
+    await promises$1.mkdir(types.configuration.happyDir, { recursive: true });
+  }
+  await promises$1.writeFile(types.configuration.privateKeyFile, JSON.stringify({
+    secret: types.encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
 }
 
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = node_crypto.randomUUID();
+  if (options.daemonSpawn && options.startingMode === "local") {
+    types.logger.debug("Daemon spawn requested with local mode - forcing remote mode");
+    options.startingMode = "remote";
+  }
   const api = new types.ApiClient(credentials.token, credentials.secret);
   let state = {};
-  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version, os: os.platform() };
+  const settings = await readSettings() || { };
+  let metadata = {
+    path: workingDirectory,
+    host: os.hostname(),
+    version: packageJson.version,
+    os: os.platform(),
+    machineId: settings.machineId
+  };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   types.logger.debug(`Session created: ${response.id}`);
+  if (options.daemonSpawn) {
+    console.log(`daemon:sessionIdCreated:${response.id}`);
+  }
   const session = api.session(response);
   const pushClient = api.push();
   let thinking = false;
@@ -1443,11 +1436,6 @@ async function start(credentials, options = {}) {
   let pingInterval = setInterval(() => {
     session.keepAlive(thinking, mode);
   }, 2e3);
-  const activityTracker = await startClaudeActivityTracker((newThinking) => {
-    thinking = newThinking;
-    session.keepAlive(thinking, mode);
-  });
-  process.env.ANTHROPIC_BASE_URL = activityTracker.proxyUrl;
   const logPath = await types.logger.logFilePathPromise;
   types.logger.infoDeveloper(`Session: ${response.id}`);
   types.logger.infoDeveloper(`Logs: ${logPath}`);
@@ -1579,7 +1567,6 @@ async function start(credentials, options = {}) {
     },
     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}`);
@@ -1589,13 +1576,14 @@ async function start(credentials, options = {}) {
     },
     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();
+      thinking = false;
+      session.keepAlive(thinking, mode);
     },
     mcpServers: {
       "permission": {
@@ -1608,61 +1596,16 @@ async function start(credentials, options = {}) {
     onAssistantResult,
     interruptController,
     claudeEnvVars: options.claudeEnvVars,
-    claudeArgs: options.claudeArgs
+    claudeArgs: options.claudeArgs,
+    onThinkingChange: (newThinking) => {
+      thinking = newThinking;
+      session.keepAlive(thinking, mode);
+    }
   });
   clearInterval(pingInterval);
   process.exit(0);
 }
 
-const defaultSettings = {
-  onboardingCompleted: false
-};
-async function readSettings() {
-  if (!node_fs.existsSync(types.configuration.settingsFile)) {
-    return { ...defaultSettings };
-  }
-  try {
-    const content = await promises$1.readFile(types.configuration.settingsFile, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return { ...defaultSettings };
-  }
-}
-async function writeSettings(settings) {
-  if (!node_fs.existsSync(types.configuration.happyDir)) {
-    await promises$1.mkdir(types.configuration.happyDir, { recursive: true });
-  }
-  await promises$1.writeFile(types.configuration.settingsFile, JSON.stringify(settings, null, 2));
-}
-const credentialsSchema = z__namespace.object({
-  secret: z__namespace.string().base64(),
-  token: z__namespace.string()
-});
-async function readCredentials() {
-  if (!node_fs.existsSync(types.configuration.privateKeyFile)) {
-    return null;
-  }
-  try {
-    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")),
-      token: credentials.token
-    };
-  } catch {
-    return null;
-  }
-}
-async function writeCredentials(credentials) {
-  if (!node_fs.existsSync(types.configuration.happyDir)) {
-    await promises$1.mkdir(types.configuration.happyDir, { recursive: true });
-  }
-  await promises$1.writeFile(types.configuration.privateKeyFile, JSON.stringify({
-    secret: types.encodeBase64(credentials.secret),
-    token: credentials.token
-  }, null, 2));
-}
-
 function displayQRCode(url) {
   console.log("=".repeat(80));
   console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
@@ -1690,10 +1633,8 @@ async function doAuth() {
   console.log("Please, authenticate using mobile app");
   const authUrl = "happy://terminal?" + types.encodeBase64Url(keypair.publicKey);
   displayQRCode(authUrl);
-  if (process.env.DEBUG === "1") {
-    console.log("\n\u{1F4CB} For manual entry, copy this URL:");
-    console.log(authUrl);
-  }
+  console.log("\n\u{1F4CB} For manual entry, copy this URL:");
+  console.log(authUrl);
   let credentials = null;
   while (true) {
     try {
@@ -1741,18 +1682,20 @@ class ApiDaemonSession extends node_events.EventEmitter {
   keepAliveInterval = null;
   token;
   secret;
+  spawnedProcesses = /* @__PURE__ */ new Set();
   constructor(token, secret, machineIdentity) {
     super();
     this.token = token;
     this.secret = secret;
     this.machineIdentity = machineIdentity;
+    types.logger.daemonDebug(`Connecting to server: ${types.configuration.serverUrl}`);
     const socket = socket_ioClient.io(types.configuration.serverUrl, {
       auth: {
         token: this.token,
         clientType: "machine-scoped",
         machineId: this.machineIdentity.machineId
       },
-      path: "/v1/user-machine-daemon",
+      path: "/v1/updates",
       reconnection: true,
       reconnectionAttempts: Infinity,
       reconnectionDelay: 1e3,
@@ -1762,68 +1705,146 @@ class ApiDaemonSession extends node_events.EventEmitter {
       autoConnect: false
     });
     socket.on("connect", () => {
-      types.logger.debug("[DAEMON] Connected to server");
+      types.logger.daemonDebug("Socket connected");
+      types.logger.daemonDebug(`Connected with auth - token: ${this.token.substring(0, 10)}..., machineId: ${this.machineIdentity.machineId}`);
+      const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
+      socket.emit("rpc-register", { method: rpcMethod });
+      types.logger.daemonDebug(`Emitted RPC registration: ${rpcMethod}`);
       this.emit("connected");
-      socket.emit("machine-connect", {
-        token: this.token,
-        machineIdentity: types.encodeBase64(types.encrypt(this.machineIdentity, this.secret))
-      });
       this.startKeepAlive();
     });
-    socket.on("disconnect", () => {
-      types.logger.debug("[DAEMON] Disconnected from server");
-      this.emit("disconnected");
-      this.stopKeepAlive();
-    });
-    socket.on("spawn-session", async (encryptedData, callback) => {
-      let requestData;
-      try {
-        requestData = types.decrypt(types.decodeBase64(encryptedData), this.secret);
-        types.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
-          `;
-          child_process.spawn("osascript", ["-e", script], { detached: true });
-        } else {
-          const child = child_process.spawn("happy", args, {
+    socket.on("rpc-request", async (data, callback) => {
+      types.logger.daemonDebug(`Received RPC request: ${JSON.stringify(data)}`);
+      const expectedMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
+      if (data.method === expectedMethod) {
+        types.logger.daemonDebug("Processing spawn-happy-session RPC");
+        try {
+          const { directory } = data.params || {};
+          if (!directory) {
+            throw new Error("Directory is required");
+          }
+          const args = [
+            "--daemon-spawn",
+            "--happy-starting-mode",
+            "remote"
+            // ALWAYS force remote mode for daemon spawns
+          ];
+          if (types.configuration.installationLocation === "local") {
+            args.push("--local");
+          }
+          if (types.configuration.serverUrl !== "https://handy-api.korshakov.org") {
+            args.push("--happy-server-url", types.configuration.serverUrl);
+          }
+          types.logger.daemonDebug(`Spawning happy in directory: ${directory} with args: ${args.join(" ")}`);
+          const happyPath = process.argv[1];
+          const isTypeScript = happyPath.endsWith(".ts");
+          const happyProcess = isTypeScript ? child_process.spawn("npx", ["tsx", happyPath, ...args], {
+            cwd: directory,
+            env: { ...process.env, EXPERIMENTAL_FEATURES: "1" },
+            detached: true,
+            stdio: ["ignore", "pipe", "pipe"]
+            // We need stdout
+          }) : child_process.spawn(process.argv[0], [happyPath, ...args], {
+            cwd: directory,
+            env: { ...process.env, EXPERIMENTAL_FEATURES: "1" },
             detached: true,
-            stdio: "ignore",
-            cwd: requestData.directory
+            stdio: ["ignore", "pipe", "pipe"]
+            // We need stdout
+          });
+          this.spawnedProcesses.add(happyProcess);
+          let sessionId = null;
+          let output = "";
+          let timeoutId = null;
+          const cleanup = () => {
+            happyProcess.stdout.removeAllListeners("data");
+            happyProcess.stderr.removeAllListeners("data");
+            happyProcess.removeAllListeners("error");
+            happyProcess.removeAllListeners("exit");
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+              timeoutId = null;
+            }
+          };
+          happyProcess.stdout.on("data", (data2) => {
+            output += data2.toString();
+            const match = output.match(/daemon:sessionIdCreated:(.+?)[\n\r]/);
+            if (match && !sessionId) {
+              sessionId = match[1];
+              types.logger.daemonDebug(`Session spawned successfully: ${sessionId}`);
+              callback({ sessionId });
+              cleanup();
+              happyProcess.unref();
+            }
+          });
+          happyProcess.stderr.on("data", (data2) => {
+            types.logger.daemonDebug(`Spawned process stderr: ${data2.toString()}`);
+          });
+          happyProcess.on("error", (error) => {
+            types.logger.daemonDebug("Error spawning session:", error);
+            if (!sessionId) {
+              callback({ error: `Failed to spawn: ${error.message}` });
+              cleanup();
+              this.spawnedProcesses.delete(happyProcess);
+            }
           });
-          child.unref();
+          happyProcess.on("exit", (code, signal) => {
+            types.logger.daemonDebug(`Spawned process exited with code ${code}, signal ${signal}`);
+            this.spawnedProcesses.delete(happyProcess);
+            if (!sessionId) {
+              callback({ error: `Process exited before session ID received` });
+              cleanup();
+            }
+          });
+          timeoutId = setTimeout(() => {
+            if (!sessionId) {
+              types.logger.daemonDebug("Timeout waiting for session ID");
+              callback({ error: "Timeout waiting for session" });
+              cleanup();
+              happyProcess.kill();
+              this.spawnedProcesses.delete(happyProcess);
+            }
+          }, 1e4);
+        } catch (error) {
+          types.logger.daemonDebug("Error spawning session:", error);
+          callback({ error: error instanceof Error ? error.message : "Unknown error" });
         }
-        const result = { success: true };
-        socket.emit("session-spawn-result", {
-          requestId: requestData.requestId,
-          result: types.encodeBase64(types.encrypt(result, this.secret))
-        });
-        callback(types.encodeBase64(types.encrypt({ success: true }, this.secret)));
-      } catch (error) {
-        types.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: types.encodeBase64(types.encrypt(errorResult, this.secret))
-        });
-        callback(types.encodeBase64(types.encrypt(errorResult, this.secret)));
+      } else {
+        types.logger.daemonDebug(`Unknown RPC method: ${data.method}`);
+        callback({ error: `Unknown method: ${data.method}` });
+      }
+    });
+    socket.on("disconnect", (reason) => {
+      types.logger.daemonDebug(`Disconnected from server. Reason: ${reason}`);
+      this.emit("disconnected");
+      this.stopKeepAlive();
+    });
+    socket.on("reconnect", () => {
+      types.logger.daemonDebug("Reconnected to server");
+      const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
+      socket.emit("rpc-register", { method: rpcMethod });
+      types.logger.daemonDebug(`Re-registered RPC method: ${rpcMethod}`);
+    });
+    socket.on("rpc-registered", (data) => {
+      types.logger.daemonDebug(`RPC registration confirmed: ${data.method}`);
+    });
+    socket.on("rpc-unregistered", (data) => {
+      types.logger.daemonDebug(`RPC unregistered: ${data.method}`);
+    });
+    socket.on("rpc-error", (data) => {
+      types.logger.daemonDebug(`RPC error: ${JSON.stringify(data)}`);
+    });
+    socket.onAny((event, ...args) => {
+      if (!event.startsWith("machine-alive")) {
+        types.logger.daemonDebug(`Socket event: ${event}, args: ${JSON.stringify(args)}`);
       }
     });
+    socket.on("connect_error", (error) => {
+      types.logger.daemonDebug(`Connection error: ${error.message}`);
+      types.logger.daemonDebug(`Error: ${JSON.stringify(error, null, 2)}`);
+    });
+    socket.on("error", (error) => {
+      types.logger.daemonDebug(`Socket error: ${error}`);
+    });
     socket.on("daemon-command", (data) => {
       switch (data.command) {
         case "shutdown":
@@ -1839,6 +1860,7 @@ class ApiDaemonSession extends node_events.EventEmitter {
   startKeepAlive() {
     this.stopKeepAlive();
     this.keepAliveInterval = setInterval(() => {
+      types.logger.daemonDebug("Sending keep-alive ping");
       this.socket.volatile.emit("machine-alive", {
         time: Date.now()
       });
@@ -1854,22 +1876,42 @@ class ApiDaemonSession extends node_events.EventEmitter {
     this.socket.connect();
   }
   shutdown() {
+    types.logger.daemonDebug(`Shutting down daemon, killing ${this.spawnedProcesses.size} spawned processes`);
+    for (const process2 of this.spawnedProcesses) {
+      try {
+        types.logger.daemonDebug(`Killing spawned process with PID: ${process2.pid}`);
+        process2.kill("SIGTERM");
+        setTimeout(() => {
+          try {
+            process2.kill("SIGKILL");
+          } catch (e) {
+          }
+        }, 1e3);
+      } catch (error) {
+        types.logger.daemonDebug(`Error killing process: ${error}`);
+      }
+    }
+    this.spawnedProcesses.clear();
     this.stopKeepAlive();
     this.socket.close();
     this.emit("shutdown");
   }
 }
 
+let pidFileFd = null;
 async function startDaemon() {
-  console.log("[DAEMON] Starting daemon process...");
+  if (process.platform !== "darwin") {
+    console.error("ERROR: Daemon is only supported on macOS");
+    process.exit(1);
+  }
+  types.logger.daemonDebug("Starting daemon process...");
+  types.logger.daemonDebug(`Server URL: ${types.configuration.serverUrl}`);
   if (await isDaemonRunning()) {
-    console.log("Happy daemon is already running");
+    types.logger.daemonDebug("Happy daemon is already running");
     process.exit(0);
   }
-  console.log("[DAEMON] Writing PID file with PID:", process.pid);
-  writePidFile();
-  console.log("[DAEMON] PID file written successfully");
-  types.logger.info("Happy CLI daemon started successfully");
+  pidFileFd = writePidFile();
+  types.logger.daemonDebug("PID file written");
   process.on("SIGINT", () => {
     stopDaemon().catch(console.error);
   });
@@ -1894,7 +1936,7 @@ async function startDaemon() {
     };
     let credentials = await readCredentials();
     if (!credentials) {
-      types.logger.debug("[DAEMON] No credentials found, running auth");
+      types.logger.daemonDebug("No credentials found, running auth");
       await doAuth();
       credentials = await readCredentials();
       if (!credentials) {
@@ -1902,64 +1944,64 @@ async function startDaemon() {
       }
     }
     const { token, secret } = credentials;
-    const daemon = new ApiDaemonSession(token, secret, machineIdentity);
+    const daemon = new ApiDaemonSession(
+      token,
+      secret,
+      machineIdentity
+    );
     daemon.on("connected", () => {
-      types.logger.debug("[DAEMON] Successfully connected to server");
+      types.logger.daemonDebug("Connected to server event received");
     });
     daemon.on("disconnected", () => {
-      types.logger.debug("[DAEMON] Disconnected from server");
+      types.logger.daemonDebug("Disconnected from server event received");
     });
     daemon.on("shutdown", () => {
-      types.logger.debug("[DAEMON] Shutdown requested");
+      types.logger.daemonDebug("Shutdown requested");
       stopDaemon();
       process.exit(0);
     });
     daemon.connect();
-    setInterval(() => {
-    }, 1e3);
+    types.logger.daemonDebug("Daemon started successfully");
   } catch (error) {
-    types.logger.debug("[DAEMON] Failed to start daemon", error);
+    types.logger.daemonDebug("Failed to start daemon", error);
     stopDaemon();
     process.exit(1);
   }
-  process.on("SIGINT", () => process.exit(0));
-  process.on("SIGTERM", () => process.exit(0));
-  process.on("exit", () => process.exit(0));
   while (true) {
     await new Promise((resolve) => setTimeout(resolve, 1e3));
   }
 }
 async function isDaemonRunning() {
   try {
-    console.log("[isDaemonRunning] Checking if daemon is running...");
+    types.logger.daemonDebug("[isDaemonRunning] Checking if daemon is running...");
     if (fs.existsSync(types.configuration.daemonPidFile)) {
-      console.log("[isDaemonRunning] PID file exists");
+      types.logger.daemonDebug("[isDaemonRunning] PID file exists");
       const pid = parseInt(fs.readFileSync(types.configuration.daemonPidFile, "utf-8"));
-      console.log("[isDaemonRunning] PID from file:", pid);
+      types.logger.daemonDebug("[isDaemonRunning] PID from file:", pid);
       try {
         process.kill(pid, 0);
-        console.log("[isDaemonRunning] Process exists, checking if it's a happy daemon...");
+        types.logger.daemonDebug("[isDaemonRunning] Process exists, checking if it's a happy daemon...");
         const isHappyDaemon = await isProcessHappyDaemon(pid);
-        console.log("[isDaemonRunning] isHappyDaemon:", isHappyDaemon);
+        types.logger.daemonDebug("[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`);
+          types.logger.daemonDebug("[isDaemonRunning] PID is not a happy daemon, cleaning up");
+          types.logger.debug(`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");
+        types.logger.daemonDebug("[isDaemonRunning] Process not running, cleaning up stale PID file");
+        types.logger.debug("Process not running, cleaning up stale PID file");
         fs.unlinkSync(types.configuration.daemonPidFile);
       }
     } else {
-      console.log("[isDaemonRunning] No PID file found");
+      types.logger.daemonDebug("[isDaemonRunning] No PID file found");
     }
     return false;
   } catch (error) {
-    console.log("[isDaemonRunning] Error:", error);
-    types.logger.debug("[DAEMON] Error checking daemon status", error);
+    types.logger.daemonDebug("[isDaemonRunning] Error:", error);
+    types.logger.debug("Error checking daemon status", error);
     return false;
   }
 }
@@ -1969,20 +2011,46 @@ function writePidFile() {
     fs.mkdirSync(happyDir, { recursive: true });
   }
   try {
-    fs.writeFileSync(types.configuration.daemonPidFile, process.pid.toString(), { flag: "wx" });
+    const fd = fs.openSync(types.configuration.daemonPidFile, "wx");
+    fs.writeSync(fd, process.pid.toString());
+    return fd;
   } 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");
+      try {
+        const fd = fs.openSync(types.configuration.daemonPidFile, "r+");
+        const existingPid = fs.readFileSync(types.configuration.daemonPidFile, "utf-8").trim();
+        fs.closeSync(fd);
+        try {
+          process.kill(parseInt(existingPid), 0);
+          types.logger.daemonDebug("PID file exists and process is running");
+          types.logger.daemonDebug("Happy daemon is already running");
+          process.exit(0);
+        } catch {
+          types.logger.daemonDebug("PID file exists but process is dead, cleaning up");
+          fs.unlinkSync(types.configuration.daemonPidFile);
+          return writePidFile();
+        }
+      } catch (lockError) {
+        types.logger.daemonDebug("Cannot acquire write lock on PID file, daemon is running");
+        types.logger.daemonDebug("Happy daemon is already running");
+        process.exit(0);
+      }
     }
     throw error;
   }
 }
 async function stopDaemon() {
   try {
+    if (pidFileFd !== null) {
+      try {
+        fs.closeSync(pidFileFd);
+      } catch {
+      }
+      pidFileFd = null;
+    }
     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}`);
+      types.logger.debug(`Stopping daemon with PID ${pid}`);
       try {
         process.kill(pid, "SIGTERM");
         await new Promise((resolve) => setTimeout(resolve, 1e3));
@@ -1992,12 +2060,12 @@ async function stopDaemon() {
         } catch {
         }
       } catch (error) {
-        types.logger.debug("[DAEMON] Process already dead or inaccessible", error);
+        types.logger.debug("Process already dead or inaccessible", error);
       }
       fs.unlinkSync(types.configuration.daemonPidFile);
     }
   } catch (error) {
-    types.logger.debug("[DAEMON] Error stopping daemon", error);
+    types.logger.debug("Error stopping daemon", error);
   }
 }
 async function isProcessHappyDaemon(pid) {
@@ -2145,7 +2213,12 @@ async function uninstall() {
 (async () => {
   const args = process.argv.slice(2);
   let installationLocation = args.includes("--local") || process.env.HANDY_LOCAL ? "local" : "global";
-  types.initializeConfiguration(installationLocation);
+  let serverUrl;
+  const serverUrlIndex = args.indexOf("--happy-server-url");
+  if (serverUrlIndex !== -1 && serverUrlIndex + 1 < args.length) {
+    serverUrl = args[serverUrlIndex + 1];
+  }
+  types.initializeConfiguration(installationLocation, serverUrl);
   types.initLoggerWithGlobalConfiguration();
   types.logger.debug("Starting happy CLI with args: ", process.argv);
   const subcommand = args[0];
@@ -2227,6 +2300,10 @@ Currently only supported on macOS.
       } else if (arg === "--claude-arg") {
         const claudeArg = args[++i];
         options.claudeArgs = [...options.claudeArgs || [], claudeArg];
+      } else if (arg === "--daemon-spawn") {
+        options.daemonSpawn = true;
+      } else if (arg === "--happy-server-url") {
+        i++;
       } else {
         console.error(chalk.red(`Unknown argument: ${arg}`));
         process.exit(1);
@@ -2262,6 +2339,8 @@ ${chalk.bold("Options:")}
       You will require re-login each time you run this in a new directory.
   --happy-starting-mode <interactive|remote>
       Set the starting mode for new sessions (default: remote)
+  --happy-server-url <url>
+      Set the server URL (overrides HANDY_SERVER_URL environment variable)
 
 ${chalk.bold("Examples:")}
   happy                   Start a session with default settings
@@ -2288,7 +2367,71 @@ ${chalk.bold("Examples:")}
       }
       credentials = res;
     }
-    await readSettings() || { };
+    const settings = await readSettings() || { onboardingCompleted: false };
+    process.env.EXPERIMENTAL_FEATURES !== void 0;
+    if (settings.daemonAutoStartWhenRunningHappy === void 0) {
+      console.log(chalk.cyan("\n\u{1F680} Happy Daemon Setup\n"));
+      const rl = node_readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      console.log(chalk.cyan("\n\u{1F4F1} Happy can run a background service that allows you to:"));
+      console.log(chalk.cyan("  \u2022 Spawn new conversations from your phone"));
+      console.log(chalk.cyan("  \u2022 Continue closed conversations remotely"));
+      console.log(chalk.cyan("  \u2022 Work with Claude while your computer has internet\n"));
+      const answer = await new Promise((resolve) => {
+        rl.question(chalk.green("Would you like Happy to start this service automatically? (recommended) [Y/n]: "), resolve);
+      });
+      rl.close();
+      const shouldAutoStart = answer.toLowerCase() !== "n";
+      settings.daemonAutoStartWhenRunningHappy = shouldAutoStart;
+      if (shouldAutoStart) {
+        console.log(chalk.green("\u2713 Happy will start the background service automatically"));
+        console.log(chalk.gray("  The service will run whenever you use the happy command"));
+      } else {
+        console.log(chalk.yellow("  You can enable this later by running: happy daemon install"));
+      }
+      await writeSettings(settings);
+    }
+    if (settings.daemonAutoStartWhenRunningHappy) {
+      console.log("Starting Happy background service...");
+      if (!await isDaemonRunning()) {
+        const happyPath = process.argv[1];
+        const isBuiltBinary = happyPath.endsWith("/bin/happy") || happyPath.endsWith("\\bin\\happy");
+        const daemonArgs = ["daemon", "start"];
+        if (serverUrl) {
+          daemonArgs.push("--happy-server-url", serverUrl);
+        }
+        if (installationLocation === "local") {
+          daemonArgs.push("--local");
+        }
+        const daemonProcess = isBuiltBinary ? child_process.spawn(happyPath, daemonArgs, {
+          detached: true,
+          stdio: ["ignore", "inherit", "inherit"],
+          // Show stdout/stderr for debugging
+          env: {
+            ...process.env,
+            HANDY_SERVER_URL: serverUrl || process.env.HANDY_SERVER_URL,
+            // Pass through server URL
+            HANDY_LOCAL: process.env.HANDY_LOCAL
+            // Pass through local flag
+          }
+        }) : child_process.spawn("npx", ["tsx", happyPath, ...daemonArgs], {
+          detached: true,
+          stdio: ["ignore", "inherit", "inherit"],
+          // Show stdout/stderr for debugging
+          env: {
+            ...process.env,
+            HANDY_SERVER_URL: serverUrl || process.env.HANDY_SERVER_URL,
+            // Pass through server URL
+            HANDY_LOCAL: process.env.HANDY_LOCAL
+            // Pass through local flag
+          }
+        });
+        daemonProcess.unref();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+    }
     try {
       await start(credentials, options);
     } catch (error) {