happy-coder 0.6.4 → 0.7.1-beta.1

package/dist/index.mjs

@@ -1,21 +1,21 @@
 import chalk from 'chalk';
-import { l as logger, d as backoff, e as delay, R as RawJSONLinesSchema, c as configuration, f as encodeBase64, A as ApiClient, g as encodeBase64Url, h as decodeBase64, j as encrypt, b as initializeConfiguration, i as initLoggerWithGlobalConfiguration } from './types-Dz5kZrVh.mjs';
+import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, c as configuration, e as encodeBase64, A as ApiClient, f as encodeBase64Url, g as decodeBase64 } from './types-BZC9-exR.mjs';
 import { randomUUID, randomBytes } from 'node:crypto';
 import { spawn, execSync } from 'node:child_process';
 import { resolve, join, dirname as dirname$1 } from 'node:path';
 import { createInterface } from 'node:readline';
 import { fileURLToPath as fileURLToPath$1 } from 'node:url';
-import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, watch, constants, readdirSync, statSync, rmSync } from 'node:fs';
 import os, { homedir } from 'node:os';
 import { dirname, resolve as resolve$1, join as join$1 } from 'path';
 import { fileURLToPath } from 'url';
-import { readFile, mkdir, writeFile as writeFile$1 } from 'node:fs/promises';
+import { readFile, unlink, mkdir, writeFile as writeFile$1, open, stat as stat$1, rename } from 'node:fs/promises';
 import { watch as watch$1, access, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
 import axios from 'axios';
-import { EventEmitter } from 'node:events';
-import { io } from 'socket.io-client';
+import 'node:events';
+import 'socket.io-client';
 import tweetnacl from 'tweetnacl';
 import 'expo-server-sdk';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
@@ -25,11 +25,13 @@ import * as z from 'zod';
 import { z as z$1 } from 'zod';
 import { spawn as spawn$1, exec, execSync as execSync$1 } from 'child_process';
 import { promisify } from 'util';
-import crypto, { createHash } from 'crypto';
+import { createHash } from 'crypto';
 import qrcode from 'qrcode-terminal';
-import open from 'open';
-import { existsSync as existsSync$1, readFileSync as readFileSync$1, writeFileSync, unlinkSync, mkdirSync as mkdirSync$1, chmodSync } from 'fs';
-import { hostname, homedir as homedir$1 } from 'os';
+import open$1 from 'open';
+import fastify from 'fastify';
+import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
+import os$1 from 'os';
+import { existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
 
 class Session {
   path;
@@ -83,7 +85,8 @@ class Session {
 
 function getProjectPath(workingDirectory) {
   const projectId = resolve(workingDirectory).replace(/[\\\/\.:]/g, "-");
-  return join(homedir(), ".claude", "projects", projectId);
+  const claudeConfigDir = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  return join(claudeConfigDir, "projects", projectId);
 }
 
 function claudeCheckSession(sessionId, path) {
@@ -2030,31 +2033,39 @@ class SDKToLogConverter {
 }
 
 async function claudeRemoteLauncher(session) {
+  logger.debug("[claudeRemoteLauncher] Starting remote launcher");
+  const hasTTY = process.stdout.isTTY && process.stdin.isTTY;
+  logger.debug(`[claudeRemoteLauncher] TTY available: ${hasTTY}`);
   let messageBuffer = new MessageBuffer();
-  console.clear();
-  let inkInstance = render(React.createElement(RemoteModeDisplay, {
-    messageBuffer,
-    logPath: process.env.DEBUG ? session.logPath : void 0,
-    onExit: async () => {
-      logger.debug("[remote]: Exiting client via Ctrl-C");
-      if (!exitReason) {
-        exitReason = "exit";
+  let inkInstance = null;
+  if (hasTTY) {
+    console.clear();
+    inkInstance = render(React.createElement(RemoteModeDisplay, {
+      messageBuffer,
+      logPath: process.env.DEBUG ? session.logPath : void 0,
+      onExit: async () => {
+        logger.debug("[remote]: Exiting client via Ctrl-C");
+        if (!exitReason) {
+          exitReason = "exit";
+        }
+        await abort();
+      },
+      onSwitchToLocal: () => {
+        logger.debug("[remote]: Switching to local mode via double space");
+        doSwitch();
       }
-      await abort();
-    },
-    onSwitchToLocal: () => {
-      logger.debug("[remote]: Switching to local mode via double space");
-      doSwitch();
+    }), {
+      exitOnCtrlC: false,
+      patchConsole: false
+    });
+  }
+  if (hasTTY) {
+    process.stdin.resume();
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
     }
-  }), {
-    exitOnCtrlC: false,
-    patchConsole: false
-  });
-  process.stdin.resume();
-  if (process.stdin.isTTY) {
-    process.stdin.setRawMode(true);
+    process.stdin.setEncoding("utf8");
   }
-  process.stdin.setEncoding("utf8");
   const scanner = await createSessionScanner({
     sessionId: session.sessionId,
     workingDirectory: session.path,
@@ -2274,7 +2285,9 @@ async function claudeRemoteLauncher(session) {
     if (process.stdin.isTTY) {
       process.stdin.setRawMode(false);
     }
-    inkInstance.unmount();
+    if (inkInstance) {
+      inkInstance.unmount();
+    }
     messageBuffer.clear();
     if (abortFuture) {
       abortFuture.resolve(void 0);
@@ -2330,7 +2343,7 @@ async function loop(opts) {
 }
 
 var name = "happy-coder";
-var version = "0.6.4";
+var version = "0.7.1-beta.1";
 var description = "Claude Code session sharing CLI";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";
@@ -2374,15 +2387,21 @@ var files = [
 	"package.json"
 ];
 var scripts = {
-	test: "vitest run",
+	"why do we need to build before running tests / dev?": "We need the binary to be built so we run daemon commands which directly run the binary - we don't want them to go out of sync or have custom spawn logic depending how we started happy",
+	typecheck: "tsc --noEmit",
+	build: "shx rm -rf dist && npx tsc --noEmit && pkgroll",
+	test: "yarn build && vitest run",
 	"test:watch": "vitest",
-	build: "shx rm -rf dist && tsc --noEmit && pkgroll",
+	"test:integration-test-env": "yarn build && tsx --env-file .env.integration-test node_modules/.bin/vitest run",
+	dev: "yarn build && npx tsx src/index.ts",
+	"dev:local-server": "yarn build && tsx --env-file .env.dev-local-server src/index.ts",
+	"dev:integration-test-env": "yarn build && tsx --env-file .env.integration-test src/index.ts",
 	prepublishOnly: "yarn build && yarn test",
-	typecheck: "tsc --noEmit",
-	dev: "yarn build && npx tsx --env-file .env.sample src/index.ts",
-	"dev:local-server": "yarn build && cross-env HANDY_SERVER_URL=http://localhost:3005 tsx --env-file .env.sample src/index.ts",
-	"version:prerelease": "npm version prerelease --preid=beta",
-	"publish:prerelease": "npm publish --tag beta"
+	"minor:publish": "yarn build && npm version minor && npm publish",
+	"patch:publish": "yarn build && npm version patch && npm publish",
+	"version:prerelease": "yarn build && npm version prerelease --preid=beta",
+	"publish:prerelease": "npm publish --tag beta",
+	"beta:publish": "yarn version:prerelease && yarn publish:prerelease"
 };
 var dependencies = {
 	"@anthropic-ai/claude-code": "^1.0.73",
@@ -2395,6 +2414,8 @@ var dependencies = {
 	axios: "^1.10.0",
 	chalk: "^5.4.1",
 	"expo-server-sdk": "^3.15.0",
+	fastify: "^5.5.0",
+	"fastify-type-provider-zod": "4.0.2",
 	"http-proxy": "^1.18.1",
 	"http-proxy-middleware": "^3.0.5",
 	ink: "^6.1.0",
@@ -2484,8 +2505,8 @@ function registerHandlers(session) {
       const { stdout, stderr } = await execAsync(data.command, options);
       return {
         success: true,
-        stdout: stdout || "",
-        stderr: stderr || "",
+        stdout: stdout ? stdout.toString() : "",
+        stderr: stderr ? stderr.toString() : "",
         exitCode: 0
       };
     } catch (error) {
@@ -2501,8 +2522,8 @@ function registerHandlers(session) {
       }
       return {
         success: false,
-        stdout: execError.stdout || "",
-        stderr: execError.stderr || execError.message || "Command failed",
+        stdout: execError.stdout ? execError.stdout.toString() : "",
+        stderr: execError.stderr ? execError.stderr.toString() : execError.message || "Command failed",
         exitCode: typeof execError.code === "number" ? execError.code : 1,
         error: execError.message || "Command failed"
       };
@@ -2669,8 +2690,8 @@ function registerHandlers(session) {
       return {
         success: true,
         exitCode: result.exitCode,
-        stdout: result.stdout,
-        stderr: result.stderr
+        stdout: result.stdout.toString(),
+        stderr: result.stderr.toString()
       };
     } catch (error) {
       logger.debug("Failed to run ripgrep:", error);
@@ -2680,6 +2701,26 @@ function registerHandlers(session) {
       };
     }
   });
+  session.setHandler("killSession", async () => {
+    logger.debug("Kill session request received");
+    try {
+      const response = {
+        success: true,
+        message: "Session termination acknowledged, exiting in 100ms"
+      };
+      setTimeout(() => {
+        logger.debug("[KILL SESSION] Exiting process as requested");
+        process.exit(0);
+      }, 100);
+      return response;
+    } catch (error) {
+      logger.debug("Failed to kill session:", error);
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Failed to kill session"
+      };
+    }
+  });
 }
 
 const defaultSettings = {
@@ -2696,11 +2737,52 @@ async function readSettings() {
     return { ...defaultSettings };
   }
 }
-async function writeSettings(settings) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
+async function updateSettings(updater) {
+  const LOCK_RETRY_INTERVAL_MS = 100;
+  const MAX_LOCK_ATTEMPTS = 50;
+  const STALE_LOCK_TIMEOUT_MS = 1e4;
+  const lockFile = configuration.settingsFile + ".lock";
+  const tmpFile = configuration.settingsFile + ".tmp";
+  let fileHandle;
+  let attempts = 0;
+  while (attempts < MAX_LOCK_ATTEMPTS) {
+    try {
+      fileHandle = await open(lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+        try {
+          const stats = await stat$1(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await unlink(lockFile).catch(() => {
+            });
+          }
+        } catch {
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!fileHandle) {
+    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
+  }
+  try {
+    const current = await readSettings() || { ...defaultSettings };
+    const updated = await updater(current);
+    if (!existsSync(configuration.happyHomeDir)) {
+      await mkdir(configuration.happyHomeDir, { recursive: true });
+    }
+    await writeFile$1(tmpFile, JSON.stringify(updated, null, 2));
+    await rename(tmpFile, configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await unlink(lockFile).catch(() => {
+    });
   }
-  await writeFile$1(configuration.settingsFile, JSON.stringify(settings, null, 2));
 }
 const credentialsSchema = z.object({
   secret: z.string().base64(),
@@ -2722,14 +2804,47 @@ async function readCredentials() {
   }
 }
 async function writeCredentials(credentials) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
+  if (!existsSync(configuration.happyHomeDir)) {
+    await mkdir(configuration.happyHomeDir, { recursive: true });
   }
   await writeFile$1(configuration.privateKeyFile, JSON.stringify({
     secret: encodeBase64(credentials.secret),
     token: credentials.token
   }, null, 2));
 }
+async function clearCredentials() {
+  if (existsSync(configuration.privateKeyFile)) {
+    await unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await readFile(configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    return null;
+  }
+}
+async function writeDaemonState(state) {
+  if (!existsSync(configuration.happyHomeDir)) {
+    await mkdir(configuration.happyHomeDir, { recursive: true });
+  }
+  await writeFile$1(configuration.daemonStateFile, JSON.stringify(state, null, 2));
+}
+async function clearDaemonState() {
+  if (existsSync(configuration.daemonStateFile)) {
+    await unlink(configuration.daemonStateFile);
+  }
+}
 
 class MessageQueue2 {
   constructor(modeHasher) {
@@ -3092,8 +3207,13 @@ function startCaffeinate() {
     return false;
   }
 }
+let isStopping = false;
 function stopCaffeinate() {
+  if (isStopping) {
+    return;
+  }
   if (caffeinateProcess && !caffeinateProcess.killed) {
+    isStopping = true;
     logger.debug(`[caffeinate] Stopping caffeinate process PID ${caffeinateProcess.pid}`);
     try {
       caffeinateProcess.kill("SIGTERM");
@@ -3103,9 +3223,11 @@ function stopCaffeinate() {
           caffeinateProcess.kill("SIGKILL");
         }
         caffeinateProcess = null;
+        isStopping = false;
       }, 1e3);
     } catch (error) {
       logger.debug("[caffeinate] Error stopping caffeinate:", error);
+      isStopping = false;
     }
   }
 }
@@ -3180,30 +3302,441 @@ function extractSDKMetadataAsync(onComplete) {
   });
 }
 
+async function isDaemonRunning() {
+  try {
+    const state = await getDaemonState();
+    if (!state) {
+      return false;
+    }
+    const isRunning = await isDaemonProcessRunning(state.pid);
+    if (!isRunning) {
+      logger.debug("[DAEMON RUN] Daemon PID not running, cleaning up state");
+      await cleanupDaemonState();
+      return false;
+    }
+    return true;
+  } catch (error) {
+    logger.debug("[DAEMON RUN] Error checking daemon status", error);
+    return false;
+  }
+}
+async function getDaemonState() {
+  try {
+    return await readDaemonState();
+  } catch (error) {
+    logger.debug("[DAEMON RUN] Error reading daemon metadata", error);
+    return null;
+  }
+}
+async function isDaemonProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function cleanupDaemonState() {
+  try {
+    await clearDaemonState();
+    logger.debug("[DAEMON RUN] Daemon state file removed");
+  } catch (error) {
+    logger.debug("[DAEMON RUN] Error cleaning up daemon metadata", error);
+  }
+}
+function findAllHappyProcesses() {
+  try {
+    const output = execSync('ps aux | grep "happy.mjs" | grep -v grep', { encoding: "utf8" });
+    const lines = output.trim().split("\n").filter((line) => line.trim());
+    const allProcesses = [];
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 11) continue;
+      const pid = parseInt(parts[1]);
+      const command = parts.slice(10).join(" ");
+      let type = "unknown";
+      if (pid === process.pid) {
+        type = "current";
+      } else if (command.includes("daemon start-sync") || command.includes("daemon start")) {
+        type = "daemon";
+      } else if (command.includes("--started-by daemon")) {
+        type = "daemon-spawned-session";
+      } else if (command.includes("doctor")) {
+        type = "doctor";
+      } else {
+        type = "user-session";
+      }
+      allProcesses.push({ pid, command, type });
+    }
+    try {
+      const devOutput = execSync('ps aux | grep -E "(tsx.*src/index.ts|yarn.*tsx)" | grep -v grep', { encoding: "utf8" });
+      const devLines = devOutput.trim().split("\n").filter((line) => line.trim());
+      for (const line of devLines) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 11) continue;
+        const pid = parseInt(parts[1]);
+        const command = parts.slice(10).join(" ");
+        let workingDir = "";
+        try {
+          const pwdOutput = execSync(`pwdx ${pid} 2>/dev/null`, { encoding: "utf8" });
+          workingDir = pwdOutput.replace(`${pid}:`, "").trim();
+        } catch {
+        }
+        if (workingDir.includes("happy-cli")) {
+          allProcesses.push({ pid, command, type: "dev-session" });
+        }
+      }
+    } catch {
+    }
+    return allProcesses;
+  } catch (error) {
+    return [];
+  }
+}
+function findRunawayHappyProcesses() {
+  try {
+    const output = execSync('ps aux | grep "happy.mjs" | grep -v grep', { encoding: "utf8" });
+    const lines = output.trim().split("\n").filter((line) => line.trim());
+    const processes = [];
+    for (const line of lines) {
+      const parts = line.trim().split(/\s+/);
+      if (parts.length < 11) continue;
+      const pid = parseInt(parts[1]);
+      const command = parts.slice(10).join(" ");
+      if (pid === process.pid) continue;
+      if (command.includes("--started-by daemon") || command.includes("daemon start-sync") || command.includes("daemon start")) {
+        processes.push({ pid, command });
+      }
+    }
+    return processes;
+  } catch (error) {
+    return [];
+  }
+}
+async function killRunawayHappyProcesses() {
+  const runawayProcesses = findRunawayHappyProcesses();
+  const errors = [];
+  let killed = 0;
+  for (const { pid, command } of runawayProcesses) {
+    try {
+      process.kill(pid, "SIGTERM");
+      await new Promise((resolve) => setTimeout(resolve, 1e3));
+      try {
+        process.kill(pid, 0);
+        console.log(`Process PID ${pid} ignored SIGTERM, using SIGKILL`);
+        process.kill(pid, "SIGKILL");
+      } catch {
+      }
+      killed++;
+      console.log(`Killed runaway process PID ${pid}: ${command}`);
+    } catch (error) {
+      errors.push({ pid, error: error.message });
+    }
+  }
+  return { killed, errors };
+}
+async function stopDaemon() {
+  try {
+    stopCaffeinate();
+    logger.debug("Stopped sleep prevention");
+    const state = await getDaemonState();
+    if (!state) {
+      logger.debug("No daemon state found");
+      return;
+    }
+    logger.debug(`Stopping daemon with PID ${state.pid}`);
+    try {
+      const { stopDaemonHttp } = await Promise.resolve().then(function () { return controlClient; });
+      await stopDaemonHttp();
+      await waitForProcessDeath(state.pid, 5e3);
+      logger.debug("Daemon stopped gracefully via HTTP");
+      return;
+    } catch (error) {
+      logger.debug("HTTP stop failed, will force kill", error);
+    }
+    try {
+      process.kill(state.pid, "SIGKILL");
+      logger.debug("Force killed daemon");
+    } catch (error) {
+      logger.debug("Daemon already dead");
+    }
+  } catch (error) {
+    logger.debug("Error stopping daemon", error);
+  }
+}
+async function waitForProcessDeath(pid, timeout) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    try {
+      process.kill(pid, 0);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    } catch {
+      return;
+    }
+  }
+  throw new Error("Process did not die within timeout");
+}
+
+var utils = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    cleanupDaemonState: cleanupDaemonState,
+    findAllHappyProcesses: findAllHappyProcesses,
+    findRunawayHappyProcesses: findRunawayHappyProcesses,
+    getDaemonState: getDaemonState,
+    isDaemonRunning: isDaemonRunning,
+    killRunawayHappyProcesses: killRunawayHappyProcesses,
+    stopDaemon: stopDaemon
+});
+
+function getEnvironmentInfo() {
+  return {
+    PWD: process.env.PWD,
+    HAPPY_HOME_DIR: process.env.HAPPY_HOME_DIR,
+    HAPPY_SERVER_URL: process.env.HAPPY_SERVER_URL,
+    HAPPY_PROJECT_ROOT: process.env.HAPPY_PROJECT_ROOT,
+    DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING: process.env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING,
+    NODE_ENV: process.env.NODE_ENV,
+    DEBUG: process.env.DEBUG,
+    workingDirectory: process.cwd(),
+    processArgv: process.argv,
+    happyDir: configuration?.happyHomeDir,
+    serverUrl: configuration?.serverUrl,
+    logsDir: configuration?.logsDir
+  };
+}
+function getLogFiles(logDir) {
+  if (!existsSync(logDir)) {
+    return [];
+  }
+  try {
+    return readdirSync(logDir).filter((file) => file.endsWith(".log")).map((file) => {
+      const path = join(logDir, file);
+      const stats = statSync(path);
+      return { file, path, modified: stats.mtime };
+    }).sort((a, b) => b.modified.getTime() - a.modified.getTime()).slice(0, 10);
+  } catch {
+    return [];
+  }
+}
+async function runDoctorCommand() {
+  console.log(chalk.bold.cyan("\n\u{1FA7A} Happy CLI Doctor\n"));
+  console.log(chalk.bold("\u{1F4CB} Basic Information"));
+  console.log(`Happy CLI Version: ${chalk.green(packageJson.version)}`);
+  console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
+  console.log(`Node.js Version: ${chalk.green(process.version)}`);
+  console.log("");
+  console.log(chalk.bold("\u2699\uFE0F  Configuration"));
+  console.log(`Happy Home: ${chalk.blue(configuration.happyHomeDir)}`);
+  console.log(`Server URL: ${chalk.blue(configuration.serverUrl)}`);
+  console.log(`Logs Dir: ${chalk.blue(configuration.logsDir)}`);
+  console.log(chalk.bold("\n\u{1F30D} Environment Variables"));
+  const env = getEnvironmentInfo();
+  console.log(`HAPPY_HOME_DIR: ${env.HAPPY_HOME_DIR ? chalk.green(env.HAPPY_HOME_DIR) : chalk.gray("not set")}`);
+  console.log(`HAPPY_SERVER_URL: ${env.HAPPY_SERVER_URL ? chalk.green(env.HAPPY_SERVER_URL) : chalk.gray("not set")}`);
+  console.log(`DANGEROUSLY_LOG_TO_SERVER: ${env.DANGEROUSLY_LOG_TO_SERVER_FOR_AI_AUTO_DEBUGGING ? chalk.yellow("ENABLED") : chalk.gray("not set")}`);
+  console.log(`DEBUG: ${env.DEBUG ? chalk.green(env.DEBUG) : chalk.gray("not set")}`);
+  console.log(`NODE_ENV: ${env.NODE_ENV ? chalk.green(env.NODE_ENV) : chalk.gray("not set")}`);
+  try {
+    const settings = await readSettings();
+    console.log(chalk.bold("\n\u{1F4C4} Settings (settings.json):"));
+    console.log(chalk.gray(JSON.stringify(settings, null, 2)));
+  } catch (error) {
+    console.log(chalk.bold("\n\u{1F4C4} Settings:"));
+    console.log(chalk.red("\u274C Failed to read settings"));
+  }
+  console.log(chalk.bold("\n\u{1F510} Authentication"));
+  try {
+    const credentials = await readCredentials();
+    if (credentials) {
+      console.log(chalk.green("\u2713 Authenticated (credentials found)"));
+    } else {
+      console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated (no credentials)"));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error reading credentials"));
+  }
+  console.log(chalk.bold("\n\u{1F916} Daemon Status"));
+  try {
+    const isRunning = await isDaemonRunning();
+    const state = await getDaemonState();
+    if (isRunning && state) {
+      console.log(chalk.green("\u2713 Daemon is running"));
+      console.log(`  PID: ${state.pid}`);
+      console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
+      console.log(`  CLI Version: ${state.startedWithCliVersion}`);
+      if (state.httpPort) {
+        console.log(`  HTTP Port: ${state.httpPort}`);
+      }
+    } else if (state && !isRunning) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Daemon state exists but process not running (stale)"));
+    } else {
+      console.log(chalk.red("\u274C Daemon is not running"));
+    }
+    if (state) {
+      console.log(chalk.bold("\n\u{1F4C4} Daemon State:"));
+      console.log(chalk.blue(`Location: ${configuration.daemonStateFile}`));
+      console.log(chalk.gray(JSON.stringify(state, null, 2)));
+    }
+    const allProcesses = findAllHappyProcesses();
+    if (allProcesses.length > 0) {
+      console.log(chalk.bold("\n\u{1F50D} All Happy CLI Processes"));
+      const grouped = allProcesses.reduce((groups, process2) => {
+        if (!groups[process2.type]) groups[process2.type] = [];
+        groups[process2.type].push(process2);
+        return groups;
+      }, {});
+      Object.entries(grouped).forEach(([type, processes]) => {
+        const typeLabels = {
+          "current": "\u{1F4CD} Current Process",
+          "daemon": "\u{1F916} Daemon",
+          "daemon-spawned-session": "\u{1F517} Daemon-Spawned Sessions",
+          "user-session": "\u{1F464} User Sessions",
+          "dev-daemon": "\u{1F6E0}\uFE0F  Dev Daemon",
+          "dev-session": "\u{1F6E0}\uFE0F  Dev Sessions",
+          "dev-doctor": "\u{1F6E0}\uFE0F  Dev Doctor",
+          "dev-related": "\u{1F6E0}\uFE0F  Dev Related",
+          "doctor": "\u{1FA7A} Doctor",
+          "unknown": "\u2753 Unknown"
+        };
+        console.log(chalk.blue(`
+${typeLabels[type] || type}:`));
+        processes.forEach(({ pid, command }) => {
+          const color = type === "current" ? chalk.green : type.startsWith("dev") ? chalk.cyan : type.includes("daemon") ? chalk.blue : chalk.gray;
+          console.log(`  ${color(`PID ${pid}`)}: ${chalk.gray(command)}`);
+        });
+      });
+    }
+    const runawayProcesses = findRunawayHappyProcesses();
+    if (runawayProcesses.length > 0) {
+      console.log(chalk.bold("\n\u{1F6A8} Runaway Happy processes detected"));
+      console.log(chalk.gray("These processes were left running after daemon crashes."));
+      runawayProcesses.forEach(({ pid, command }) => {
+        console.log(`  ${chalk.yellow(`PID ${pid}`)}: ${chalk.gray(command)}`);
+      });
+      console.log(chalk.blue("\nTo clean up: happy daemon kill-runaway"));
+    }
+    if (allProcesses.length > 1) {
+      console.log(chalk.bold("\n\u{1F4A1} Process Management"));
+      console.log(chalk.gray("To kill runaway processes: happy daemon kill-runaway"));
+    }
+  } catch (error) {
+    console.log(chalk.red("\u274C Error checking daemon status"));
+  }
+  console.log(chalk.bold("\n\u{1F4DD} Log Files"));
+  const mainLogs = getLogFiles(configuration.logsDir);
+  if (mainLogs.length > 0) {
+    console.log(chalk.blue("\nMain Logs:"));
+    mainLogs.forEach(({ file, path, modified }) => {
+      console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
+      console.log(chalk.gray(`    ${path}`));
+    });
+  } else {
+    console.log(chalk.yellow("No main log files found"));
+  }
+  const daemonLogs = mainLogs.filter(({ file }) => file.includes("daemon"));
+  if (daemonLogs.length > 0) {
+    console.log(chalk.blue("\nDaemon Logs:"));
+    daemonLogs.forEach(({ file, path, modified }) => {
+      console.log(`  ${chalk.green(file)} - ${modified.toLocaleString()}`);
+      console.log(chalk.gray(`    ${path}`));
+    });
+  } else {
+    console.log(chalk.yellow("No daemon log files found"));
+  }
+  console.log(chalk.bold("\n\u{1F41B} Support & Bug Reports"));
+  console.log(`Report issues: ${chalk.blue("https://github.com/slopus/happy-cli/issues")}`);
+  console.log(`Documentation: ${chalk.blue("https://happy.engineering/")}`);
+  console.log(chalk.green("\n\u2705 Doctor diagnosis complete!\n"));
+}
+
+async function daemonPost(path, body) {
+  const state = await getDaemonState();
+  if (!state?.httpPort) {
+    throw new Error("No daemon running");
+  }
+  try {
+    const response = await fetch(`http://127.0.0.1:${state.httpPort}${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(body || {}),
+      signal: AbortSignal.timeout(5e3)
+    });
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}`);
+    }
+    return await response.json();
+  } catch (error) {
+    logger.debug(`[CONTROL CLIENT] Request failed: ${path}`, error);
+    throw error;
+  }
+}
+async function notifyDaemonSessionStarted(sessionId, metadata) {
+  await daemonPost("/session-started", {
+    sessionId,
+    metadata
+  });
+}
+async function listDaemonSessions() {
+  const result = await daemonPost("/list");
+  return result.children || [];
+}
+async function stopDaemonSession(sessionId) {
+  const result = await daemonPost("/stop-session", { sessionId });
+  return result.success || false;
+}
+async function stopDaemonHttp() {
+  await daemonPost("/stop");
+}
+
+var controlClient = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    listDaemonSessions: listDaemonSessions,
+    notifyDaemonSessionStarted: notifyDaemonSessionStarted,
+    stopDaemonHttp: stopDaemonHttp,
+    stopDaemonSession: stopDaemonSession
+});
+
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = randomUUID();
-  if (options.daemonSpawn && options.startingMode === "local") {
+  logger.debugLargeJson("[START] Happy process started", getEnvironmentInfo());
+  logger.debug(`[START] Options: startedBy=${options.startedBy}, startingMode=${options.startingMode}`);
+  if (options.startedBy === "daemon" && options.startingMode === "local") {
     logger.debug("Daemon spawn requested with local mode - forcing remote mode");
     options.startingMode = "remote";
   }
   const api = new ApiClient(credentials.token, credentials.secret);
   let state = {};
-  const settings = await readSettings() || { };
+  const settings = await readSettings();
+  const machineId = settings?.machineId || "unknown";
+  logger.debug(`Using machineId: ${machineId}`);
   let metadata = {
     path: workingDirectory,
     host: os.hostname(),
     version: packageJson.version,
     os: os.platform(),
-    machineId: settings.machineId,
-    homeDir: os.homedir()
+    machineId,
+    homeDir: os.homedir(),
+    happyHomeDir: configuration.happyHomeDir,
+    startedFromDaemon: options.startedBy === "daemon",
+    hostPid: process.pid,
+    startedBy: options.startedBy || "terminal"
   };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   logger.debug(`Session created: ${response.id}`);
+  try {
+    const daemonState = await getDaemonState();
+    if (daemonState?.httpPort) {
+      await notifyDaemonSessionStarted(response.id, metadata);
+      logger.debug(`[START] Reported session ${response.id} to daemon`);
+    }
+  } catch (error) {
+    logger.debug("[START] Failed to report to daemon (may not be running):", error);
+  }
   extractSDKMetadataAsync(async (sdkMetadata) => {
     logger.debug("[start] SDK metadata extracted, updating session:", sdkMetadata);
     try {
-      api.session(response).updateMetadata((currentMetadata) => ({
+      api.sessionSyncClient(response).updateMetadata((currentMetadata) => ({
         ...currentMetadata,
         tools: sdkMetadata.tools,
         slashCommands: sdkMetadata.slashCommands
@@ -3213,10 +3746,7 @@ async function start(credentials, options = {}) {
       logger.debug("[start] Failed to update session metadata:", error);
     }
   });
-  if (options.daemonSpawn) {
-    console.log(`daemon:sessionIdCreated:${response.id}`);
-  }
-  const session = api.session(response);
+  const session = api.sessionSyncClient(response);
   const logPath = await logger.logFilePathPromise;
   logger.infoDeveloper(`Session: ${response.id}`);
   logger.infoDeveloper(`Logs: ${logPath}`);
@@ -3342,6 +3872,32 @@ async function start(credentials, options = {}) {
     messageQueue.push(message.content.text, enhancedMode);
     logger.debugLargeJson("User message pushed to queue:", message);
   });
+  const cleanup = async () => {
+    logger.debug("[START] Received termination signal, cleaning up...");
+    try {
+      if (session) {
+        session.sendSessionDeath();
+        await session.flush();
+        await session.close();
+      }
+      stopCaffeinate();
+      logger.debug("[START] Cleanup complete, exiting");
+      process.exit(0);
+    } catch (error) {
+      logger.debug("[START] Error during cleanup:", error);
+      process.exit(1);
+    }
+  };
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("uncaughtException", (error) => {
+    logger.debug("[START] Uncaught exception:", error);
+    cleanup();
+  });
+  process.on("unhandledRejection", (reason) => {
+    logger.debug("[START] Unhandled rejection:", reason);
+    cleanup();
+  });
   await loop({
     path: workingDirectory,
     model: options.model,
@@ -3397,7 +3953,7 @@ async function openBrowser(url) {
       return false;
     }
     logger.debug(`[browser] Attempting to open URL: ${url}`);
-    await open(url);
+    await open$1(url);
     logger.debug("[browser] Browser opened successfully");
     return true;
   } catch (error) {
@@ -3451,10 +4007,14 @@ async function doAuth() {
   const secret = new Uint8Array(randomBytes(32));
   const keypair = tweetnacl.box.keyPair.fromSecretKey(secret);
   try {
+    console.log(`[AUTH DEBUG] Sending auth request to: ${configuration.serverUrl}/v1/auth/request`);
+    console.log(`[AUTH DEBUG] Public key: ${encodeBase64(keypair.publicKey).substring(0, 20)}...`);
     await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
       publicKey: encodeBase64(keypair.publicKey)
     });
+    console.log(`[AUTH DEBUG] Auth request sent successfully`);
   } catch (error) {
+    console.log(`[AUTH DEBUG] Failed to send auth request:`, error);
     console.log("Failed to create authentication request, please try again later.");
     return null;
   }
@@ -3571,550 +4131,375 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
   }
   return decrypted;
 }
+async function authAndSetupMachineIfNeeded() {
+  logger.debug("[AUTH] Starting auth and machine setup...");
+  let credentials = await readCredentials();
+  if (!credentials) {
+    logger.debug("[AUTH] No credentials found, starting authentication flow...");
+    const authResult = await doAuth();
+    if (!authResult) {
+      throw new Error("Authentication failed or was cancelled");
+    }
+    credentials = authResult;
+  } else {
+    logger.debug("[AUTH] Using existing credentials");
+  }
+  const settings = await updateSettings(async (s) => {
+    if (!s.machineId) {
+      return {
+        ...s,
+        machineId: randomUUID()
+      };
+    }
+    return s;
+  });
+  logger.debug(`[AUTH] Machine ID: ${settings.machineId}`);
+  return { credentials, machineId: settings.machineId };
+}
 
-class ApiDaemonSession extends EventEmitter {
-  socket;
-  machineIdentity;
-  keepAliveInterval = null;
-  token;
-  secret;
-  spawnedProcesses = /* @__PURE__ */ new Set();
-  machineRegistered = false;
-  constructor(token, secret, machineIdentity) {
-    super();
-    this.token = token;
-    this.secret = secret;
-    this.machineIdentity = machineIdentity;
-    logger.debug(`[DAEMON SESSION] Connecting to server: ${configuration.serverUrl}`);
-    const socket = io(configuration.serverUrl, {
-      auth: {
-        token: this.token,
-        clientType: "machine-scoped",
-        machineId: this.machineIdentity.machineId
-      },
-      path: "/v1/updates",
-      reconnection: true,
-      reconnectionAttempts: Infinity,
-      reconnectionDelay: 1e3,
-      reconnectionDelayMax: 5e3,
-      transports: ["websocket"],
-      withCredentials: true,
-      autoConnect: false
-    });
-    socket.on("connect", async () => {
-      logger.debug("[DAEMON SESSION] Socket connected");
-      logger.debug(`[DAEMON SESSION] Connected with auth - token: ${this.token.substring(0, 10)}..., machineId: ${this.machineIdentity.machineId}`);
-      if (!this.machineRegistered) {
-        await this.registerMachine();
-      }
-      const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
-      socket.emit("rpc-register", { method: rpcMethod });
-      logger.debug(`[DAEMON SESSION] Emitted RPC registration: ${rpcMethod}`);
-      this.emit("connected");
-      this.startKeepAlive();
+function startDaemonControlServer({
+  getChildren,
+  stopSession,
+  spawnSession,
+  requestShutdown,
+  onHappySessionWebhook
+}) {
+  return new Promise((resolve) => {
+    const app = fastify({
+      logger: false
+      // We use our own logger
     });
-    socket.on("rpc-request", async (data, callback) => {
-      logger.debug(`[DAEMON SESSION] Received RPC request: ${JSON.stringify(data)}`);
-      const expectedMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
-      if (data.method === expectedMethod) {
-        logger.debug("[DAEMON SESSION] Processing spawn-happy-session RPC");
-        try {
-          const { directory } = data.params || {};
-          if (!directory) {
-            throw new Error("Directory is required");
-          }
-          const args = [
-            "--daemon-spawn",
-            "--happy-starting-mode",
-            "remote"
-            // ALWAYS force remote mode for daemon spawns
-          ];
-          if (configuration.installationLocation === "local") {
-            args.push("--local");
-          }
-          logger.debug(`[DAEMON SESSION] Spawning happy in directory: ${directory} with args: ${args.join(" ")}`);
-          const happyBinPath = join$1(projectPath(), "bin", "happy.mjs");
-          logger.debug(`[DAEMON SESSION] Using happy binary at: ${happyBinPath}`);
-          const executable = happyBinPath;
-          const spawnArgs = args;
-          logger.debug(`[DAEMON SESSION] Spawn: executable=${executable}, args=${JSON.stringify(spawnArgs)}, cwd=${directory}`);
-          const happyProcess = spawn$1(executable, spawnArgs, {
-            cwd: directory,
-            detached: true,
-            stdio: ["ignore", "pipe", "pipe"]
-            // We need stdout
-          });
-          this.spawnedProcesses.add(happyProcess);
-          this.updateChildPidsInMetadata();
-          let sessionId = null;
-          let output = "";
-          let timeoutId = null;
-          const cleanup = () => {
-            happyProcess.stdout.removeAllListeners("data");
-            happyProcess.stderr.removeAllListeners("data");
-            happyProcess.removeAllListeners("error");
-            happyProcess.removeAllListeners("exit");
-            if (timeoutId) {
-              clearTimeout(timeoutId);
-              timeoutId = null;
-            }
-          };
-          happyProcess.stdout.on("data", (data2) => {
-            output += data2.toString();
-            const match = output.match(/daemon:sessionIdCreated:(.+?)[\n\r]/);
-            if (match && !sessionId) {
-              sessionId = match[1];
-              logger.debug(`[DAEMON SESSION] Session spawned successfully: ${sessionId}`);
-              callback({ sessionId });
-              cleanup();
-              happyProcess.unref();
-            }
-          });
-          happyProcess.stderr.on("data", (data2) => {
-            logger.debug(`[DAEMON SESSION] Spawned process stderr: ${data2.toString()}`);
-          });
-          happyProcess.on("error", (error) => {
-            logger.debug("[DAEMON SESSION] Error spawning session:", error);
-            if (!sessionId) {
-              callback({ error: `Failed to spawn: ${error.message}` });
-              cleanup();
-              this.spawnedProcesses.delete(happyProcess);
-            }
-          });
-          happyProcess.on("exit", (code, signal) => {
-            logger.debug(`[DAEMON SESSION] Spawned process exited with code ${code}, signal ${signal}`);
-            this.spawnedProcesses.delete(happyProcess);
-            this.updateChildPidsInMetadata();
-            if (!sessionId) {
-              callback({ error: `Process exited before session ID received` });
-              cleanup();
-            }
-          });
-          timeoutId = setTimeout(() => {
-            if (!sessionId) {
-              logger.debug("[DAEMON SESSION] Timeout waiting for session ID");
-              callback({ error: "Timeout waiting for session" });
-              cleanup();
-              happyProcess.kill();
-              this.spawnedProcesses.delete(happyProcess);
-              this.updateChildPidsInMetadata();
-            }
-          }, 1e4);
-        } catch (error) {
-          logger.debug("[DAEMON SESSION] Error spawning session:", error);
-          callback({ error: error instanceof Error ? error.message : "Unknown error" });
-        }
-      } else {
-        logger.debug(`[DAEMON SESSION] Unknown RPC method: ${data.method}`);
-        callback({ error: `Unknown method: ${data.method}` });
+    app.setValidatorCompiler(validatorCompiler);
+    app.setSerializerCompiler(serializerCompiler);
+    const typed = app.withTypeProvider();
+    typed.post("/session-started", {
+      schema: {
+        body: z$1.object({
+          sessionId: z$1.string(),
+          metadata: z$1.any()
+          // Metadata type from API
+        })
       }
+    }, async (request, reply) => {
+      const { sessionId, metadata } = request.body;
+      logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
+      onHappySessionWebhook(sessionId, metadata);
+      return { status: "ok" };
     });
-    socket.on("disconnect", (reason) => {
-      logger.debug(`[DAEMON SESSION] Disconnected from server. Reason: ${reason}`);
-      this.emit("disconnected");
-      this.stopKeepAlive();
-    });
-    socket.on("reconnect", () => {
-      logger.debug("[DAEMON SESSION] Reconnected to server");
-      const rpcMethod = `${this.machineIdentity.machineId}:spawn-happy-session`;
-      socket.emit("rpc-register", { method: rpcMethod });
-      logger.debug(`[DAEMON SESSION] Re-registered RPC method: ${rpcMethod}`);
+    typed.post("/list", async (request, reply) => {
+      const children = getChildren();
+      logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
+      return { children };
     });
-    socket.on("rpc-registered", (data) => {
-      logger.debug(`[DAEMON SESSION] RPC registration confirmed: ${data.method}`);
-    });
-    socket.on("rpc-unregistered", (data) => {
-      logger.debug(`[DAEMON SESSION] RPC unregistered: ${data.method}`);
-    });
-    socket.on("rpc-error", (data) => {
-      logger.debug(`[DAEMON SESSION] RPC error: ${JSON.stringify(data)}`);
-    });
-    socket.onAny((event, ...args) => {
-      if (!event.startsWith("session-alive") && event !== "ephemeral") {
-        logger.debug(`[DAEMON SESSION] Socket event: ${event}, args: ${JSON.stringify(args)}`);
+    typed.post("/stop-session", {
+      schema: {
+        body: z$1.object({
+          sessionId: z$1.string()
+        })
       }
+    }, async (request, reply) => {
+      const { sessionId } = request.body;
+      logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
+      const success = stopSession(sessionId);
+      return { success };
     });
-    socket.on("connect_error", (error) => {
-      logger.debug(`[DAEMON SESSION] Connection error: ${error.message}`);
-      logger.debug(`[DAEMON SESSION] Error: ${JSON.stringify(error, null, 2)}`);
-    });
-    socket.on("error", (error) => {
-      logger.debug(`[DAEMON SESSION] Socket error: ${error}`);
-    });
-    socket.on("daemon-command", (data) => {
-      switch (data.command) {
-        case "shutdown":
-          this.shutdown();
-          break;
-        case "status":
-          this.emit("status-request");
-          break;
-      }
-    });
-    this.socket = socket;
-  }
-  async registerMachine() {
-    try {
-      const metadata = {
-        host: this.machineIdentity.machineHost,
-        platform: this.machineIdentity.platform,
-        happyCliVersion: this.machineIdentity.happyCliVersion,
-        happyHomeDirectory: this.machineIdentity.happyHomeDirectory
-      };
-      const encrypted = encrypt(JSON.stringify(metadata), this.secret);
-      const encryptedMetadata = encodeBase64(encrypted);
-      const response = await fetch(`${configuration.serverUrl}/v1/machines`, {
-        method: "POST",
-        headers: {
-          "Authorization": `Bearer ${this.token}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({
-          id: this.machineIdentity.machineId,
-          metadata: encryptedMetadata
+    typed.post("/spawn-session", {
+      schema: {
+        body: z$1.object({
+          directory: z$1.string(),
+          sessionId: z$1.string().optional()
         })
-      });
-      if (response.ok) {
-        logger.debug("[DAEMON SESSION] Machine registered/updated successfully");
-        this.machineRegistered = true;
-      } else {
-        logger.debug(`[DAEMON SESSION] Failed to register machine: ${response.status}`);
       }
-    } catch (error) {
-      logger.debug("[DAEMON SESSION] Failed to register machine:", error);
-    }
-  }
-  startKeepAlive() {
-    this.stopKeepAlive();
-    this.keepAliveInterval = setInterval(() => {
-      const payload = {
-        machineId: this.machineIdentity.machineId,
-        time: Date.now()
-      };
-      logger.debugLargeJson(`[DAEMON SESSION] Emitting machine-alive`, payload);
-      this.socket.emit("machine-alive", payload);
-    }, 2e4);
-  }
-  stopKeepAlive() {
-    if (this.keepAliveInterval) {
-      clearInterval(this.keepAliveInterval);
-      this.keepAliveInterval = null;
-    }
-  }
-  updateChildPidsInMetadata() {
-    try {
-      if (existsSync$1(configuration.daemonMetadataFile)) {
-        const content = readFileSync$1(configuration.daemonMetadataFile, "utf-8");
-        const metadata = JSON.parse(content);
-        const childPids = Array.from(this.spawnedProcesses).map((proc) => proc.pid).filter((pid) => pid !== void 0);
-        metadata.childPids = childPids;
-        writeFileSync(configuration.daemonMetadataFile, JSON.stringify(metadata, null, 2));
+    }, async (request, reply) => {
+      const { directory, sessionId } = request.body;
+      logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}`);
+      const session = await spawnSession(directory, sessionId);
+      if (session) {
+        return {
+          success: true,
+          pid: session.pid,
+          sessionId: session.happySessionId || "pending"
+        };
+      } else {
+        reply.code(500);
+        return { error: "Failed to spawn session" };
       }
-    } catch (error) {
-      logger.debug("[DAEMON SESSION] Error updating child PIDs in metadata:", error);
-    }
-  }
-  connect() {
-    this.socket.connect();
-  }
-  updateMetadata(updates) {
-    const metadata = {
-      host: this.machineIdentity.machineHost,
-      platform: this.machineIdentity.platform,
-      happyCliVersion: updates.happyCliVersion || this.machineIdentity.happyCliVersion,
-      happyHomeDirectory: updates.happyHomeDirectory || this.machineIdentity.happyHomeDirectory
-    };
-    const encrypted = encrypt(JSON.stringify(metadata), this.secret);
-    const encryptedMetadata = encodeBase64(encrypted);
-    this.socket.emit("update-machine", { metadata: encryptedMetadata });
-  }
-  shutdown() {
-    logger.debug(`[DAEMON SESSION] Shutting down daemon, killing ${this.spawnedProcesses.size} spawned processes`);
-    for (const process of this.spawnedProcesses) {
-      try {
-        logger.debug(`[DAEMON SESSION] Killing spawned process with PID: ${process.pid}`);
-        process.kill("SIGTERM");
-        setTimeout(() => {
-          try {
-            process.kill("SIGKILL");
-          } catch (e) {
-          }
-        }, 1e3);
-      } catch (error) {
-        logger.debug(`[DAEMON SESSION] Error killing process: ${error}`);
+    });
+    typed.post("/stop", async (request, reply) => {
+      logger.debug("[CONTROL SERVER] Stop daemon request received");
+      setTimeout(() => {
+        logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
+        requestShutdown();
+      }, 50);
+      return { status: "stopping" };
+    });
+    app.listen({ port: 0, host: "127.0.0.1" }, (err, address) => {
+      if (err) {
+        logger.debug("[CONTROL SERVER] Failed to start:", err);
+        throw err;
       }
-    }
-    this.spawnedProcesses.clear();
-    this.updateChildPidsInMetadata();
-    this.stopKeepAlive();
-    this.socket.close();
-    this.emit("shutdown");
-  }
+      const port = parseInt(address.split(":").pop());
+      logger.debug(`[CONTROL SERVER] Started on port ${port}`);
+      resolve({
+        port,
+        stop: async () => {
+          logger.debug("[CONTROL SERVER] Stopping server");
+          await app.close();
+          logger.debug("[CONTROL SERVER] Server stopped");
+        }
+      });
+    });
+  });
 }
 
 async function startDaemon() {
-  if (process.platform !== "darwin") {
-    console.error("ERROR: Daemon is only supported on macOS");
-    process.exit(1);
-  }
   logger.debug("[DAEMON RUN] Starting daemon process...");
-  logger.debug(`[DAEMON RUN] Server URL: ${configuration.serverUrl}`);
-  const runningDaemon = await getDaemonMetadata();
+  logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
+  const runningDaemon = await getDaemonState();
   if (runningDaemon) {
-    if (runningDaemon.version !== packageJson.version) {
-      logger.debug(`[DAEMON RUN] Daemon version mismatch (running: ${runningDaemon.version}, current: ${packageJson.version}), restarting...`);
-      await stopDaemon();
-      await new Promise((resolve) => setTimeout(resolve, 500));
-    } else if (await isDaemonProcessRunning(runningDaemon.pid)) {
-      logger.debug("[DAEMON RUN] Happy daemon is already running with correct version");
+    try {
+      process.kill(runningDaemon.pid, 0);
+      logger.debug("[DAEMON RUN] Daemon already running");
       process.exit(0);
-    } else {
-      logger.debug("[DAEMON RUN] Stale daemon metadata found, cleaning up");
-      await cleanupDaemonMetadata();
-    }
-  }
-  const oldMetadata = await getDaemonMetadata();
-  if (oldMetadata && oldMetadata.childPids && oldMetadata.childPids.length > 0) {
-    logger.debug(`[DAEMON RUN] Found ${oldMetadata.childPids.length} potential orphaned child processes from previous run`);
-    for (const childPid of oldMetadata.childPids) {
-      try {
-        process.kill(childPid, 0);
-        const isHappy = await isProcessHappyChild(childPid);
-        if (isHappy) {
-          logger.debug(`[DAEMON RUN] Killing orphaned happy process ${childPid}`);
-          process.kill(childPid, "SIGTERM");
-          await new Promise((resolve) => setTimeout(resolve, 500));
-          try {
-            process.kill(childPid, 0);
-            process.kill(childPid, "SIGKILL");
-          } catch {
-          }
-        }
-      } catch {
-        logger.debug(`[DAEMON RUN] Process ${childPid} doesn't exist (already dead)`);
-      }
+    } catch {
+      logger.debug("[DAEMON RUN] Stale state found, cleaning up");
+      await cleanupDaemonState();
     }
   }
-  writeDaemonMetadata();
-  logger.debug("[DAEMON RUN] Daemon metadata written");
   const caffeinateStarted = startCaffeinate();
   if (caffeinateStarted) {
-    logger.debug("[DAEMON RUN] Sleep prevention enabled for daemon");
+    logger.debug("[DAEMON RUN] Sleep prevention enabled");
   }
   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,
-      happyCliVersion: packageJson.version,
-      happyHomeDirectory: process.cwd()
-    };
-    let credentials = await readCredentials();
-    if (!credentials) {
-      logger.debug("[DAEMON RUN] 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 RUN] Connected to server event received");
-    });
-    daemon.on("disconnected", () => {
-      logger.debug("[DAEMON RUN] Disconnected from server event received");
-    });
-    daemon.on("shutdown", () => {
-      logger.debug("[DAEMON RUN] Shutdown requested");
-      daemon?.shutdown();
-      cleanupDaemonMetadata();
-      process.exit(0);
-    });
-    daemon.connect();
-    logger.debug("[DAEMON RUN] Daemon started successfully");
-    process.on("SIGINT", async () => {
-      logger.debug("[DAEMON RUN] Received SIGINT, shutting down...");
-      if (daemon) {
-        daemon.shutdown();
+    const { credentials, machineId } = await authAndSetupMachineIfNeeded();
+    logger.debug("[DAEMON RUN] Auth and machine setup complete");
+    const pidToTrackedSession = /* @__PURE__ */ new Map();
+    const pidToAwaiter = /* @__PURE__ */ new Map();
+    const getCurrentChildren = () => Array.from(pidToTrackedSession.values());
+    const onHappySessionWebhook = (sessionId, sessionMetadata) => {
+      const pid = sessionMetadata.hostPid;
+      if (!pid) {
+        logger.debug(`[DAEMON RUN] Session webhook missing hostPid for session ${sessionId}`);
+        return;
       }
-      await cleanupDaemonMetadata();
-      process.exit(0);
-    });
-    process.on("SIGTERM", async () => {
-      logger.debug("[DAEMON RUN] Received SIGTERM, shutting down...");
-      if (daemon) {
-        daemon.shutdown();
+      logger.debug(`[DAEMON RUN] Session webhook: ${sessionId}, PID: ${pid}, started by: ${sessionMetadata.startedBy || "unknown"}`);
+      const existingSession = pidToTrackedSession.get(pid);
+      if (existingSession && existingSession.startedBy === "daemon") {
+        existingSession.happySessionId = sessionId;
+        existingSession.happySessionMetadataFromLocalWebhook = sessionMetadata;
+        logger.debug(`[DAEMON RUN] Updated daemon-spawned session ${sessionId} with metadata`);
+        const awaiter = pidToAwaiter.get(pid);
+        if (awaiter) {
+          pidToAwaiter.delete(pid);
+          awaiter(existingSession);
+          logger.debug(`[DAEMON RUN] Resolved session awaiter for PID ${pid}`);
+        }
+      } else if (!existingSession) {
+        const trackedSession = {
+          startedBy: "happy directly - likely by user from terminal",
+          happySessionId: sessionId,
+          happySessionMetadataFromLocalWebhook: sessionMetadata,
+          pid
+        };
+        pidToTrackedSession.set(pid, trackedSession);
+        logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
       }
-      await cleanupDaemonMetadata();
-      process.exit(0);
-    });
-  } catch (error) {
-    logger.debug("[DAEMON RUN] Failed to start daemon", error);
-    stopDaemon();
-    process.exit(1);
-  }
-  while (true) {
-    await new Promise((resolve) => setTimeout(resolve, 1e3));
-  }
-}
-async function isDaemonRunning() {
-  try {
-    logger.debug("[DAEMON RUN] [isDaemonRunning] Checking if daemon is running...");
-    const metadata = await getDaemonMetadata();
-    if (!metadata) {
-      logger.debug("[DAEMON RUN] [isDaemonRunning] No daemon metadata found");
-      return false;
-    }
-    logger.debug("[DAEMON RUN] [isDaemonRunning] Daemon metadata exists");
-    logger.debug("[DAEMON RUN] [isDaemonRunning] PID from metadata:", metadata.pid);
-    const isRunning = await isDaemonProcessRunning(metadata.pid);
-    if (!isRunning) {
-      logger.debug("[DAEMON RUN] [isDaemonRunning] Process not running, cleaning up stale metadata");
-      await cleanupDaemonMetadata();
-      return false;
-    }
-    return true;
-  } catch (error) {
-    logger.debug("[DAEMON RUN] [isDaemonRunning] Error:", error);
-    logger.debug("Error checking daemon status", error);
-    return false;
-  }
-}
-async function isDaemonProcessRunning(pid) {
-  try {
-    process.kill(pid, 0);
-    logger.debug("[DAEMON RUN] Process exists, checking if it's a happy daemon...");
-    const isHappyDaemon = await isProcessHappyDaemon(pid);
-    logger.debug("[DAEMON RUN] isHappyDaemon:", isHappyDaemon);
-    return isHappyDaemon;
-  } catch (error) {
-    return false;
-  }
-}
-function writeDaemonMetadata(childPids) {
-  const happyDir = join$1(homedir$1(), ".happy");
-  if (!existsSync$1(happyDir)) {
-    mkdirSync$1(happyDir, { recursive: true });
-  }
-  const metadata = {
-    pid: process.pid,
-    startTime: (/* @__PURE__ */ new Date()).toISOString(),
-    version: packageJson.version,
-    ...childPids
-  };
-  writeFileSync(configuration.daemonMetadataFile, JSON.stringify(metadata, null, 2));
-}
-async function getDaemonMetadata() {
-  try {
-    if (!existsSync$1(configuration.daemonMetadataFile)) {
-      return null;
-    }
-    const content = readFileSync$1(configuration.daemonMetadataFile, "utf-8");
-    return JSON.parse(content);
-  } catch (error) {
-    logger.debug("Error reading daemon metadata", error);
-    return null;
-  }
-}
-async function cleanupDaemonMetadata() {
-  try {
-    if (existsSync$1(configuration.daemonMetadataFile)) {
-      unlinkSync(configuration.daemonMetadataFile);
-    }
-  } catch (error) {
-    logger.debug("Error cleaning up daemon metadata", error);
-  }
-}
-async function stopDaemon() {
-  try {
-    stopCaffeinate();
-    logger.debug("Stopped sleep prevention");
-    const metadata = await getDaemonMetadata();
-    if (metadata) {
-      logger.debug(`Stopping daemon with PID ${metadata.pid}`);
+    };
+    const spawnSession = async (directory, sessionId) => {
       try {
-        process.kill(metadata.pid, "SIGTERM");
-        await new Promise((resolve) => setTimeout(resolve, 2e3));
-        try {
-          process.kill(metadata.pid, 0);
-          logger.debug("Daemon still running, force killing...");
-          process.kill(metadata.pid, "SIGKILL");
-        } catch {
-          logger.debug("Daemon exited cleanly");
+        const happyBinPath = join$1(projectPath(), "bin", "happy.mjs");
+        const args = [
+          "--happy-starting-mode",
+          "remote",
+          "--started-by",
+          "daemon"
+        ];
+        const fullCommand = `${happyBinPath} ${args.join(" ")}`;
+        logger.debug(`[DAEMON RUN] Spawning: ${fullCommand} in ${directory}`);
+        const happyProcess = spawn$1(happyBinPath, args, {
+          cwd: directory,
+          detached: true,
+          // Sessions stay alive when daemon stops
+          stdio: ["ignore", "pipe", "pipe"]
+          // Capture stdout/stderr for debugging
+          // env is inherited automatically from parent process
+        });
+        happyProcess.stdout?.on("data", (data) => {
+          logger.debug(`[DAEMON RUN] Child stdout: ${data.toString()}`);
+        });
+        happyProcess.stderr?.on("data", (data) => {
+          logger.debug(`[DAEMON RUN] Child stderr: ${data.toString()}`);
+        });
+        if (!happyProcess.pid) {
+          logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
+          return null;
         }
+        logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
+        const trackedSession = {
+          startedBy: "daemon",
+          pid: happyProcess.pid,
+          childProcess: happyProcess
+        };
+        pidToTrackedSession.set(happyProcess.pid, trackedSession);
+        happyProcess.on("exit", (code, signal) => {
+          logger.debug(`[DAEMON RUN] Child PID ${happyProcess.pid} exited with code ${code}, signal ${signal}`);
+          if (happyProcess.pid) {
+            onChildExited(happyProcess.pid);
+          }
+        });
+        happyProcess.on("error", (error) => {
+          logger.debug(`[DAEMON RUN] Child process error:`, error);
+          if (happyProcess.pid) {
+            onChildExited(happyProcess.pid);
+          }
+        });
+        logger.debug(`[DAEMON RUN] Waiting for session webhook for PID ${happyProcess.pid}`);
+        return new Promise((resolve, reject) => {
+          const timeout = setTimeout(() => {
+            pidToAwaiter.delete(happyProcess.pid);
+            logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
+            resolve(trackedSession);
+          }, 1e4);
+          pidToAwaiter.set(happyProcess.pid, (completedSession) => {
+            clearTimeout(timeout);
+            logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
+            resolve(completedSession);
+          });
+        });
       } catch (error) {
-        logger.debug("Daemon process already dead or inaccessible", error);
+        logger.debug("[DAEMON RUN] Failed to spawn session:", error);
+        return null;
       }
-      await new Promise((resolve) => setTimeout(resolve, 500));
-      if (metadata.childPids && metadata.childPids.length > 0) {
-        logger.debug(`Checking for ${metadata.childPids.length} potential orphaned child processes...`);
-        for (const childPid of metadata.childPids) {
-          try {
-            process.kill(childPid, 0);
-            const isHappy = await isProcessHappyChild(childPid);
-            if (isHappy) {
-              logger.debug(`Killing orphaned happy process ${childPid}`);
-              process.kill(childPid, "SIGTERM");
-              await new Promise((resolve) => setTimeout(resolve, 500));
-              try {
-                process.kill(childPid, 0);
-                process.kill(childPid, "SIGKILL");
-              } catch {
-              }
+    };
+    const stopSession = (sessionId) => {
+      logger.debug(`[DAEMON RUN] Attempting to stop session ${sessionId}`);
+      for (const [pid, session] of pidToTrackedSession.entries()) {
+        if (session.happySessionId === sessionId || sessionId.startsWith("PID-") && pid === parseInt(sessionId.replace("PID-", ""))) {
+          if (session.startedBy === "daemon" && session.childProcess) {
+            try {
+              session.childProcess.kill("SIGTERM");
+              logger.debug(`[DAEMON RUN] Sent SIGTERM to daemon-spawned session ${sessionId}`);
+            } catch (error) {
+              logger.debug(`[DAEMON RUN] Failed to kill session ${sessionId}:`, error);
+            }
+          } else {
+            try {
+              process.kill(pid, "SIGTERM");
+              logger.debug(`[DAEMON RUN] Sent SIGTERM to external session PID ${pid}`);
+            } catch (error) {
+              logger.debug(`[DAEMON RUN] Failed to kill external session PID ${pid}:`, error);
             }
-          } catch {
           }
+          pidToTrackedSession.delete(pid);
+          logger.debug(`[DAEMON RUN] Removed session ${sessionId} from tracking`);
+          return true;
         }
       }
-      await cleanupDaemonMetadata();
-    }
-  } catch (error) {
-    logger.debug("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();
+      logger.debug(`[DAEMON RUN] Session ${sessionId} not found`);
+      return false;
+    };
+    const onChildExited = (pid) => {
+      logger.debug(`[DAEMON RUN] Removing exited process PID ${pid} from tracking`);
+      pidToTrackedSession.delete(pid);
+    };
+    let requestShutdown;
+    let resolvesWhenShutdownRequested = new Promise((resolve) => {
+      requestShutdown = resolve;
     });
-    ps.on("close", () => {
-      const isHappyDaemon = output.includes("daemon start") && (output.includes("happy") || output.includes("src/index"));
-      resolve(isHappyDaemon);
+    const { port: controlPort, stop: stopControlServer } = await startDaemonControlServer({
+      getChildren: getCurrentChildren,
+      stopSession,
+      spawnSession,
+      requestShutdown: () => requestShutdown("happy-cli"),
+      onHappySessionWebhook
     });
-    ps.on("error", () => {
-      resolve(false);
+    const fileState = {
+      pid: process.pid,
+      httpPort: controlPort,
+      startTime: (/* @__PURE__ */ new Date()).toISOString(),
+      startedWithCliVersion: packageJson.version
+    };
+    await writeDaemonState(fileState);
+    logger.debug("[DAEMON RUN] Daemon state written");
+    const initialMetadata = {
+      host: os$1.hostname(),
+      platform: os$1.platform(),
+      happyCliVersion: packageJson.version,
+      homeDir: os$1.homedir(),
+      happyHomeDir: configuration.happyHomeDir
+    };
+    const initialDaemonState = {
+      status: "offline",
+      pid: process.pid,
+      httpPort: controlPort,
+      startedAt: Date.now()
+    };
+    const api = new ApiClient(credentials.token, credentials.secret);
+    const machine = await api.createOrReturnExistingAsIs({
+      machineId,
+      metadata: initialMetadata,
+      daemonState: initialDaemonState
     });
-  });
-}
-async function isProcessHappyChild(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();
+    logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
+    const apiMachine = api.machineSyncClient(machine);
+    apiMachine.setRPCHandlers({
+      spawnSession,
+      stopSession,
+      requestShutdown: () => requestShutdown("happy-app")
+    });
+    apiMachine.connect();
+    const cleanupAndShutdown = async (source) => {
+      logger.debug(`[DAEMON RUN] Starting cleanup (source: ${source})...`);
+      if (apiMachine) {
+        await apiMachine.updateDaemonState((state) => ({
+          ...state,
+          status: "shutting-down",
+          shutdownRequestedAt: Date.now(),
+          shutdownSource: source === "happy-app" ? "mobile-app" : source === "happy-cli" ? "cli" : source
+        }));
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      if (apiMachine) {
+        apiMachine.shutdown();
+      }
+      logger.debug("[DAEMON RUN] Machine session shutdown");
+      await stopControlServer();
+      logger.debug("[DAEMON RUN] Control server stopped");
+      await cleanupDaemonState();
+      logger.debug("[DAEMON RUN] State cleaned up");
+      stopCaffeinate();
+      logger.debug("[DAEMON RUN] Caffeinate stopped");
+      process.exit(0);
+    };
+    process.on("SIGINT", () => {
+      logger.debug("[DAEMON RUN] Received SIGINT");
+      cleanupAndShutdown("os-signal");
     });
-    ps.on("close", () => {
-      const isHappyChild = output.includes("--daemon-spawn") && (output.includes("happy") || output.includes("src/index"));
-      resolve(isHappyChild);
+    process.on("SIGTERM", () => {
+      logger.debug("[DAEMON RUN] Received SIGTERM");
+      cleanupAndShutdown("os-signal");
     });
-    ps.on("error", () => {
-      resolve(false);
+    process.on("uncaughtException", (error) => {
+      logger.debug("[DAEMON RUN] Uncaught exception - cleaning up before crash", error);
+      cleanupAndShutdown("unknown");
     });
-  });
+    process.on("unhandledRejection", (reason) => {
+      logger.debug("[DAEMON RUN] Unhandled rejection - cleaning up before crash", reason);
+      cleanupAndShutdown("unknown");
+    });
+    process.on("exit", () => {
+      logger.debug("[DAEMON RUN] Process exit, not killing any children");
+    });
+    logger.debug("[DAEMON RUN] Daemon started successfully");
+    const shutdownSource = await resolvesWhenShutdownRequested;
+    logger.debug(`[DAEMON RUN] Shutdown requested (source: ${shutdownSource})`);
+    await cleanupAndShutdown(shutdownSource);
+  } catch (error) {
+    logger.debug("[DAEMON RUN] Failed to start daemon", error);
+    await cleanupDaemonState();
+    stopCaffeinate();
+    process.exit(1);
+  }
 }
 
 function trimIdent(text) {
@@ -4138,7 +4523,6 @@ function trimIdent(text) {
 
 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)) {
@@ -4175,10 +4559,10 @@ async function install$1() {
                 <true/>
                 
                 <key>StandardErrorPath</key>
-                <string>${USER_HOME}/.happy/daemon.err</string>
+                <string>${os$1.homedir()}/.happy/daemon.err</string>
                 
                 <key>StandardOutPath</key>
-                <string>${USER_HOME}/.happy/daemon.log</string>
+                <string>${os$1.homedir()}/.happy/daemon.log</string>
                 
                 <key>WorkingDirectory</key>
                 <string>/tmp</string>
@@ -4242,16 +4626,249 @@ async function uninstall() {
   await uninstall$1();
 }
 
+const BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+function bytesToBase32(bytes) {
+  let result = "";
+  let buffer = 0;
+  let bufferLength = 0;
+  for (const byte of bytes) {
+    buffer = buffer << 8 | byte;
+    bufferLength += 8;
+    while (bufferLength >= 5) {
+      bufferLength -= 5;
+      result += BASE32_ALPHABET[buffer >> bufferLength & 31];
+    }
+  }
+  if (bufferLength > 0) {
+    result += BASE32_ALPHABET[buffer << 5 - bufferLength & 31];
+  }
+  return result;
+}
+function formatSecretKeyForBackup(secretBytes) {
+  const base32 = bytesToBase32(secretBytes);
+  const groups = [];
+  for (let i = 0; i < base32.length; i += 5) {
+    groups.push(base32.slice(i, i + 5));
+  }
+  return groups.join("-");
+}
+
+async function handleAuthCommand(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    showAuthHelp();
+    return;
+  }
+  switch (subcommand) {
+    case "login":
+      await handleAuthLogin(args.slice(1));
+      break;
+    case "logout":
+      await handleAuthLogout();
+      break;
+    case "show-backup":
+      await handleAuthShowBackup();
+      break;
+    case "status":
+      await handleAuthStatus();
+      break;
+    default:
+      console.error(chalk.red(`Unknown auth subcommand: ${subcommand}`));
+      showAuthHelp();
+      process.exit(1);
+  }
+}
+function showAuthHelp() {
+  console.log(`
+${chalk.bold("happy auth")} - Authentication management
+
+${chalk.bold("Usage:")}
+  happy auth login [--force]    Authenticate with Happy
+  happy auth logout             Remove authentication and machine data  
+  happy auth status             Show authentication status
+  happy auth show-backup        Display backup key for mobile/web clients
+  happy auth help               Show this help message
+
+${chalk.bold("Options:")}
+  --force    Clear credentials, machine ID, and stop daemon before re-auth
+
+${chalk.bold("Examples:")}
+  happy auth login              Authenticate if not already logged in
+  happy auth login --force      Force re-authentication (complete reset)
+  happy auth status             Check authentication and machine status
+  happy auth show-backup        Get backup key to link other devices
+  happy auth logout             Remove all authentication data
+
+${chalk.bold("Notes:")} 
+  \u2022 Use 'auth login --force' when you need to re-register your machine
+  \u2022 'auth show-backup' displays the key format expected by mobile/web clients
+  \u2022 The backup key allows linking multiple devices to the same account
+`);
+}
+async function handleAuthLogin(args) {
+  const forceAuth = args.includes("--force") || args.includes("-f");
+  if (forceAuth) {
+    console.log(chalk.yellow("Force authentication requested."));
+    console.log(chalk.gray("This will:"));
+    console.log(chalk.gray("  \u2022 Clear existing credentials"));
+    console.log(chalk.gray("  \u2022 Clear machine ID"));
+    console.log(chalk.gray("  \u2022 Stop daemon if running"));
+    console.log(chalk.gray("  \u2022 Re-authenticate and register machine\n"));
+    try {
+      logger.debug("Stopping daemon for force auth...");
+      await stopDaemon();
+      console.log(chalk.gray("\u2713 Stopped daemon"));
+    } catch (error) {
+      logger.debug("Daemon was not running or failed to stop:", error);
+    }
+    await clearCredentials();
+    console.log(chalk.gray("\u2713 Cleared credentials"));
+    await clearMachineId();
+    console.log(chalk.gray("\u2713 Cleared machine ID"));
+    console.log("");
+  }
+  if (!forceAuth) {
+    const existingCreds = await readCredentials();
+    const settings = await readSettings();
+    if (existingCreds && settings?.machineId) {
+      console.log(chalk.green("\u2713 Already authenticated"));
+      console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
+      console.log(chalk.gray(`  Host: ${os.hostname()}`));
+      console.log(chalk.gray(`  Use 'happy auth login --force' to re-authenticate`));
+      return;
+    } else if (existingCreds && !settings?.machineId) {
+      console.log(chalk.yellow("\u26A0\uFE0F  Credentials exist but machine ID is missing"));
+      console.log(chalk.gray("  This can happen if --auth flag was used previously"));
+      console.log(chalk.gray("  Fixing by setting up machine...\n"));
+    }
+  }
+  try {
+    const result = await authAndSetupMachineIfNeeded();
+    console.log(chalk.green("\n\u2713 Authentication successful"));
+    console.log(chalk.gray(`  Machine ID: ${result.machineId}`));
+  } catch (error) {
+    console.error(chalk.red("Authentication failed:"), error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+}
+async function handleAuthLogout() {
+  const happyDir = configuration.happyHomeDir;
+  const credentials = await readCredentials();
+  if (!credentials) {
+    console.log(chalk.yellow("Not currently authenticated"));
+    return;
+  }
+  console.log(chalk.blue("This will log you out of Happy"));
+  console.log(chalk.yellow("\u26A0\uFE0F  You will need to re-authenticate to use Happy again"));
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await new Promise((resolve) => {
+    rl.question(chalk.yellow("Are you sure you want to log out? (y/N): "), resolve);
+  });
+  rl.close();
+  if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+    try {
+      try {
+        await stopDaemon();
+        console.log(chalk.gray("Stopped daemon"));
+      } catch {
+      }
+      if (existsSync(happyDir)) {
+        rmSync(happyDir, { recursive: true, force: true });
+      }
+      console.log(chalk.green("\u2713 Successfully logged out"));
+      console.log(chalk.gray('  Run "happy auth login" to authenticate again'));
+    } catch (error) {
+      throw new Error(`Failed to logout: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  } else {
+    console.log(chalk.blue("Logout cancelled"));
+  }
+}
+async function handleAuthShowBackup() {
+  const credentials = await readCredentials();
+  const settings = await readSettings();
+  if (!credentials) {
+    console.log(chalk.yellow("Not authenticated"));
+    console.log(chalk.gray('Run "happy auth login" to authenticate first'));
+    return;
+  }
+  const formattedBackupKey = formatSecretKeyForBackup(credentials.secret);
+  console.log(chalk.bold("\n\u{1F4F1} Backup Key\n"));
+  console.log(chalk.cyan("Your backup key:"));
+  console.log(chalk.bold(formattedBackupKey));
+  console.log("");
+  console.log(chalk.cyan("Machine Information:"));
+  console.log(`  Machine ID: ${settings?.machineId || "not set"}`);
+  console.log(`  Host: ${os.hostname()}`);
+  console.log("");
+  console.log(chalk.bold("How to use this backup key:"));
+  console.log(chalk.gray("\u2022 In Happy mobile app: Go to restore/link device and enter this key"));
+  console.log(chalk.gray("\u2022 This key format matches what the mobile app expects"));
+  console.log(chalk.gray("\u2022 You can type it with or without dashes - the app will normalize it"));
+  console.log(chalk.gray("\u2022 Common typos (0\u2192O, 1\u2192I) are automatically corrected"));
+  console.log("");
+  console.log(chalk.yellow("\u26A0\uFE0F  Keep this key secure - it provides full access to your account"));
+}
+async function handleAuthStatus() {
+  const credentials = await readCredentials();
+  const settings = await readSettings();
+  console.log(chalk.bold("\nAuthentication Status\n"));
+  if (!credentials) {
+    console.log(chalk.red("\u2717 Not authenticated"));
+    console.log(chalk.gray('  Run "happy auth login" to authenticate'));
+    return;
+  }
+  console.log(chalk.green("\u2713 Authenticated"));
+  const tokenPreview = credentials.token.substring(0, 30) + "...";
+  console.log(chalk.gray(`  Token: ${tokenPreview}`));
+  if (settings?.machineId) {
+    console.log(chalk.green("\u2713 Machine registered"));
+    console.log(chalk.gray(`  Machine ID: ${settings.machineId}`));
+    console.log(chalk.gray(`  Host: ${os.hostname()}`));
+  } else {
+    console.log(chalk.yellow("\u26A0\uFE0F  Machine not registered"));
+    console.log(chalk.gray('  Run "happy auth login --force" to fix this'));
+  }
+  console.log(chalk.gray(`
+  Data directory: ${configuration.happyHomeDir}`));
+  try {
+    const { isDaemonRunning } = await Promise.resolve().then(function () { return utils; });
+    const running = await isDaemonRunning();
+    if (running) {
+      console.log(chalk.green("\u2713 Daemon running"));
+    } else {
+      console.log(chalk.gray("\u2717 Daemon not running"));
+    }
+  } catch {
+    console.log(chalk.gray("\u2717 Daemon not running"));
+  }
+}
+
 (async () => {
   const args = process.argv.slice(2);
-  let installationLocation = args.includes("--local") || process.env.HANDY_LOCAL ? "local" : "global";
-  initializeConfiguration(installationLocation);
-  initLoggerWithGlobalConfiguration();
   logger.debug("Starting happy CLI with args: ", process.argv);
   const subcommand = args[0];
-  if (subcommand === "logout") {
+  if (subcommand === "doctor") {
+    await runDoctorCommand();
+    return;
+  } else if (subcommand === "auth") {
+    try {
+      await handleAuthCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "logout") {
+    console.log(chalk.yellow('Note: "happy logout" is deprecated. Use "happy auth logout" instead.\n'));
     try {
-      await cleanKey();
+      await handleAuthCommand(["logout"]);
     } catch (error) {
       console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
       if (process.env.DEBUG) {
@@ -4273,12 +4890,92 @@ async function uninstall() {
     return;
   } else if (subcommand === "daemon") {
     const daemonSubcommand = args[1];
-    if (daemonSubcommand === "start") {
+    if (daemonSubcommand === "list") {
+      try {
+        const sessions = await listDaemonSessions();
+        if (sessions.length === 0) {
+          console.log("No active sessions");
+        } else {
+          console.log("Active sessions:");
+          const cleanSessions = sessions.map((s) => ({
+            pid: s.pid,
+            sessionId: s.happySessionId || `PID-${s.pid}`,
+            startedBy: s.startedBy,
+            directory: s.happySessionMetadataFromLocalWebhook?.directory || "unknown"
+          }));
+          console.log(JSON.stringify(cleanSessions, null, 2));
+        }
+      } catch (error) {
+        console.log("No daemon running");
+      }
+      return;
+    } else if (daemonSubcommand === "stop-session") {
+      const sessionId = args[2];
+      if (!sessionId) {
+        console.error("Session ID required");
+        process.exit(1);
+      }
+      try {
+        const success = await stopDaemonSession(sessionId);
+        console.log(success ? "Session stopped" : "Failed to stop session");
+      } catch (error) {
+        console.log("No daemon running");
+      }
+      return;
+    } else if (daemonSubcommand === "start") {
+      const happyBinPath = join(projectPath(), "bin", "happy.mjs");
+      const child = spawn$1(happyBinPath, ["daemon", "start-sync"], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env
+      });
+      child.unref();
+      let started = false;
+      for (let i = 0; i < 50; i++) {
+        if (await isDaemonRunning()) {
+          started = true;
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      if (started) {
+        console.log("Daemon started successfully");
+      } else {
+        console.error("Failed to start daemon");
+        process.exit(1);
+      }
+      process.exit(0);
+    } else if (daemonSubcommand === "start-sync") {
       await startDaemon();
       process.exit(0);
     } else if (daemonSubcommand === "stop") {
       await stopDaemon();
       process.exit(0);
+    } else if (daemonSubcommand === "status") {
+      const state = await getDaemonState();
+      if (!state) {
+        console.log("Daemon is not running");
+      } else {
+        const isRunning = await isDaemonRunning();
+        if (isRunning) {
+          console.log("Daemon is running");
+          console.log(`  PID: ${state.pid}`);
+          console.log(`  Port: ${state.httpPort}`);
+          console.log(`  Started: ${new Date(state.startTime).toLocaleString()}`);
+          console.log(`  CLI Version: ${state.startedWithCliVersion}`);
+        } else {
+          console.log("Daemon state file exists but daemon is not running (stale)");
+        }
+      }
+      process.exit(0);
+    } else if (daemonSubcommand === "kill-runaway") {
+      const { killRunawayHappyProcesses } = await Promise.resolve().then(function () { return utils; });
+      const result = await killRunawayHappyProcesses();
+      console.log(`Killed ${result.killed} runaway processes`);
+      if (result.errors.length > 0) {
+        console.log("Errors:", result.errors);
+      }
+      process.exit(0);
     } else if (daemonSubcommand === "install") {
       try {
         await install();
@@ -4298,13 +4995,16 @@ async function uninstall() {
 ${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)
+  happy daemon start              Start the daemon (detached)
+  happy daemon stop               Stop the daemon (sessions stay alive)
+  happy daemon stop --kill-managed  Stop daemon and kill managed sessions
+  happy daemon status             Show daemon status
+  happy daemon list               List active sessions
+  happy daemon stop-session <id> Stop a specific session
+  happy daemon kill-runaway       Kill all runaway Happy processes
 
-${chalk.bold("Note:")} The daemon runs in the background and provides persistent services.
-Currently only supported on macOS.
+${chalk.bold("Note:")} The daemon runs in the background and manages Claude sessions.
+Sessions spawned by the daemon will continue running after daemon stops unless --kill-managed is used.
 `);
     }
     return;
@@ -4313,104 +5013,105 @@ Currently only supported on macOS.
     let showHelp = false;
     let showVersion = false;
     let forceAuth = false;
+    let forceAuthNew = false;
+    const unknownArgs = [];
     for (let i = 0; i < args.length; i++) {
       const arg = args[i];
-      if (arg === "-h" || arg === "--help") {
+      if (arg === "--help") {
         showHelp = true;
-      } else if (arg === "-v" || arg === "--version") {
+      } else if (arg === "--version") {
         showVersion = true;
       } else if (arg === "--auth" || arg === "--login") {
         forceAuth = true;
-      } else if (arg === "-m" || arg === "--model") {
-        options.model = args[++i];
-      } else if (arg === "-p" || arg === "--permission-mode") {
-        options.permissionMode = z$1.enum(["default", "acceptEdits", "bypassPermissions", "plan"]).parse(args[++i]);
-      } else if (arg === "--local") ; else if (arg === "--happy-starting-mode") {
+      } else if (arg === "--force-auth") {
+        forceAuthNew = true;
+      } else if (arg === "--happy-starting-mode") {
         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 if (arg === "--daemon-spawn") {
-        options.daemonSpawn = true;
+      } else if (arg === "--yolo") {
+        unknownArgs.push("--dangerously-skip-permissions");
+      } else if (arg === "--started-by") {
+        options.startedBy = args[++i];
       } else {
-        console.error(chalk.red(`Unknown argument: ${arg}`));
-        process.exit(1);
+        unknownArgs.push(arg);
+        if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+          unknownArgs.push(args[++i]);
+        }
       }
     }
+    if (unknownArgs.length > 0) {
+      options.claudeArgs = [...options.claudeArgs || [], ...unknownArgs];
+    }
     if (showHelp) {
       console.log(`
 ${chalk.bold("happy")} - Claude Code On the Go
 
 ${chalk.bold("Usage:")}
-  happy [options]
-  happy notify     Send notification
-  happy logout     Logs out of your account and removes data directory
-  happy daemon     Manage the background daemon (macOS only)
+  happy [options]          Start Claude with mobile control
+  happy auth              Manage authentication  
+  happy notify            Send push notification
+  happy daemon            Manage background service
 
-${chalk.bold("Options:")}
-  -h, --help              Show this help message
-  -v, --version           Show version
-  -m, --model <model>     Claude model to use (default: sonnet)
-  -p, --permission-mode   Permission mode: default, acceptEdits, bypassPermissions, or plan
-  --auth, --login         Force re-authentication
-  --claude-env KEY=VALUE  Set environment variable for Claude Code
-  --claude-arg ARG        Pass additional argument to Claude CLI
-
-  [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
+${chalk.bold("Happy Options:")}
+  --help                  Show this help message
+  --yolo                  Skip all permissions (--dangerously-skip-permissions)
+  --force-auth            Force re-authentication
 
-  [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 <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("\u{1F3AF} Happy supports ALL Claude options!")}
+  Use any claude flag exactly as you normally would.
 
 ${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 notify -p "Hello!"  Send notification
-  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
+  happy                   Start session
+  happy --yolo            Start without permissions
+  happy --verbose         Enable verbose mode
+  happy -c                Continue last conversation
+  happy auth login        Authenticate
+  happy notify -p "Done!" Send notification
+
+${chalk.bold("Happy is a wrapper around Claude Code that enables remote control via mobile app.")}
+${chalk.bold('Use "happy daemon" for background service management.')}
 
-[TODO: add after steve's refactor lands]
-${chalk.bold("Happy is a seamless passthrough to Claude CLI - so any commands that Claude CLI supports will work with Happy. Here is the help for Claude CLI:")}
-TODO: exec cluade --help and show inline here
+${chalk.gray("\u2500".repeat(60))}
+${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
 `);
+      const { execSync } = await import('child_process');
+      try {
+        const claudeHelp = execSync("claude --help", { encoding: "utf8" });
+        console.log(claudeHelp);
+      } catch (e) {
+        console.log(chalk.yellow("Could not retrieve claude help. Make sure claude is installed."));
+      }
       process.exit(0);
     }
     if (showVersion) {
       console.log(packageJson.version);
       process.exit(0);
     }
-    let credentials = await readCredentials();
-    if (!credentials || forceAuth) {
-      let res = await doAuth();
+    let credentials;
+    if (forceAuthNew) {
+      console.log(chalk.yellow("Force authentication requested..."));
+      try {
+        await stopDaemon();
+      } catch {
+      }
+      await clearCredentials();
+      await clearMachineId();
+      const result = await authAndSetupMachineIfNeeded();
+      credentials = result.credentials;
+    } else if (forceAuth) {
+      console.log(chalk.yellow('Note: --auth is deprecated. Use "happy auth login" or --force-auth instead.\n'));
+      const res = await doAuth();
       if (!res) {
         process.exit(1);
       }
-      credentials = res;
+      await writeCredentials(res);
+      const result = await authAndSetupMachineIfNeeded();
+      credentials = result.credentials;
+    } else {
+      const result = await authAndSetupMachineIfNeeded();
+      credentials = result.credentials;
     }
-    const settings = await readSettings() || { onboardingCompleted: false };
-    if (settings.daemonAutoStartWhenRunningHappy === void 0) {
+    let settings = await readSettings();
+    if (settings && settings.daemonAutoStartWhenRunningHappy === void 0) {
       console.log(chalk.cyan("\n\u{1F680} Happy Daemon Setup\n"));
       const rl = createInterface({
         input: process.stdin,
@@ -4425,39 +5126,28 @@ TODO: exec cluade --help and show inline here
       });
       rl.close();
       const shouldAutoStart = answer.toLowerCase() !== "n";
-      settings.daemonAutoStartWhenRunningHappy = shouldAutoStart;
+      settings = await updateSettings((settings2) => ({
+        ...settings2,
+        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) {
+    if (settings && settings.daemonAutoStartWhenRunningHappy) {
       logger.debug("Starting Happy background service...");
       if (!await isDaemonRunning()) {
-        const happyPath = process.argv[1];
-        const runningFromBuiltBinary = happyPath.endsWith("happy") || happyPath.endsWith("happy.cmd");
-        const daemonArgs = ["daemon", "start"];
-        if (installationLocation === "local") {
-          daemonArgs.push("--local");
-        }
-        let executable, args2;
-        if (runningFromBuiltBinary) {
-          executable = happyPath;
-          args2 = daemonArgs;
-        } else {
-          executable = "npx";
-          args2 = ["tsx", happyPath, ...daemonArgs];
-        }
-        const daemonProcess = spawn$1(executable, args2, {
+        const happyBinPath = join(projectPath(), "bin", "happy.mjs");
+        const daemonProcess = spawn$1(happyBinPath, ["daemon", "start-sync"], {
           detached: true,
-          stdio: ["ignore", "inherit", "inherit"]
-          // Show stdout/stderr for debugging
+          stdio: "ignore",
+          env: process.env
         });
         daemonProcess.unref();
-        await new Promise((resolve) => setTimeout(resolve, 200));
+        await new Promise((resolve) => setTimeout(resolve, 500));
       }
     }
     try {
@@ -4471,34 +5161,6 @@ TODO: exec cluade --help and show inline here
     }
   }
 })();
-async function cleanKey() {
-  const happyDir = configuration.happyDir;
-  if (!existsSync(happyDir)) {
-    console.log(chalk.yellow("No happy data directory found at:"), happyDir);
-    return;
-  }
-  console.log(chalk.blue("Found happy data directory at:"), happyDir);
-  console.log(chalk.yellow("\u26A0\uFE0F  This will remove all authentication data and require reconnecting your phone."));
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const answer = await new Promise((resolve) => {
-    rl.question(chalk.yellow("Are you sure you want to remove the happy data directory? (y/N): "), resolve);
-  });
-  rl.close();
-  if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
-    try {
-      rmSync(happyDir, { recursive: true, force: true });
-      console.log(chalk.green("\u2713 Happy data directory removed successfully"));
-      console.log(chalk.blue("\u2139\uFE0F  You will need to reconnect your phone on the next session"));
-    } catch (error) {
-      throw new Error(`Failed to remove data directory: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  } else {
-    console.log(chalk.blue("Operation cancelled"));
-  }
-}
 async function handleNotifyCommand(args) {
   let message = "";
   let title = "";