happy-coder 0.7.1-beta.3 → 0.7.2

package/dist/index.mjs

@@ -1,12 +1,12 @@
 import chalk from 'chalk';
-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 { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, c as configuration, e as encodeBase64, f as encodeBase64Url, g as decodeBase64, A as ApiClient } from './types-CJU8o8xd.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, constants, readdirSync, statSync, rmSync } from 'node:fs';
-import os, { homedir } from 'node:os';
+import os$1, { homedir } from 'node:os';
 import { dirname, resolve as resolve$1, join as join$1 } from 'path';
 import { fileURLToPath } from 'url';
 import { readFile, unlink, mkdir, writeFile as writeFile$1, open, stat as stat$1, rename } from 'node:fs/promises';
@@ -26,11 +26,11 @@ 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 { createHash } from 'crypto';
-import qrcode from 'qrcode-terminal';
-import open$1 from 'open';
 import fastify from 'fastify';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
-import os$1 from 'os';
+import os from 'os';
+import qrcode from 'qrcode-terminal';
+import open$1 from 'open';
 import { existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
 
 class Session {
@@ -2343,7 +2343,7 @@ async function loop(opts) {
 }
 
 var name = "happy-coder";
-var version = "0.7.1-beta.3";
+var version = "0.7.2";
 var description = "Claude Code session sharing CLI";
 var author = "Kirill Dubovitskiy";
 var license = "MIT";
@@ -2428,7 +2428,7 @@ var dependencies = {
 };
 var devDependencies = {
 	"@eslint/compat": "^1",
-	"@types/node": ">=18",
+	"@types/node": ">=20",
 	"cross-env": "^10.0.0",
 	eslint: "^9",
 	"eslint-config-prettier": "^10",
@@ -2439,9 +2439,10 @@ var devDependencies = {
 	typescript: "^5",
 	vitest: "^3.2.4"
 };
-var overrides = {
+var resolutions = {
 	"whatwg-url": "14.2.0"
 };
+var packageManager = "yarn@1.22.22";
 var packageJson = {
 	name: name,
 	version: version,
@@ -2461,7 +2462,8 @@ var packageJson = {
 	scripts: scripts,
 	dependencies: dependencies,
 	devDependencies: devDependencies,
-	overrides: overrides
+	resolutions: resolutions,
+	packageManager: packageManager
 };
 
 function run(args, options) {
@@ -3525,6 +3527,16 @@ async function runDoctorCommand() {
   console.log(`Platform: ${chalk.green(process.platform)} ${process.arch}`);
   console.log(`Node.js Version: ${chalk.green(process.version)}`);
   console.log("");
+  console.log(chalk.bold("\u{1F527} Daemon Spawn Diagnostics"));
+  const projectRoot = projectPath();
+  const wrapperPath = join(projectRoot, "bin", "happy.mjs");
+  const cliEntrypoint = join(projectRoot, "dist", "index.mjs");
+  console.log(`Project Root: ${chalk.blue(projectRoot)}`);
+  console.log(`Wrapper Script: ${chalk.blue(wrapperPath)}`);
+  console.log(`CLI Entrypoint: ${chalk.blue(cliEntrypoint)}`);
+  console.log(`Wrapper Exists: ${existsSync(wrapperPath) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+  console.log(`CLI Exists: ${existsSync(cliEntrypoint) ? chalk.green("\u2713 Yes") : chalk.red("\u274C No")}`);
+  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)}`);
@@ -3696,313 +3708,175 @@ var controlClient = /*#__PURE__*/Object.freeze({
     stopDaemonSession: stopDaemonSession
 });
 
-async function start(credentials, options = {}) {
-  const workingDirectory = process.cwd();
-  const sessionTag = randomUUID();
-  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 machineId = settings?.machineId || "unknown";
-  logger.debug(`Using machineId: ${machineId}`);
-  let metadata = {
-    path: workingDirectory,
-    host: os.hostname(),
-    version: packageJson.version,
-    os: os.platform(),
-    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}`);
+function startDaemonControlServer({
+  getChildren,
+  stopSession,
+  spawnSession,
+  requestShutdown,
+  onHappySessionWebhook
+}) {
+  return new Promise((resolve) => {
+    const app = fastify({
+      logger: false
+      // We use our own logger
+    });
+    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" };
+    });
+    typed.post("/list", async (request, reply) => {
+      const children = getChildren();
+      logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
+      return { children };
+    });
+    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 };
+    });
+    typed.post("/spawn-session", {
+      schema: {
+        body: z$1.object({
+          directory: z$1.string(),
+          sessionId: z$1.string().optional()
+        })
+      }
+    }, 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" };
+      }
+    });
+    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;
+      }
+      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");
+        }
+      });
+    });
+  });
+}
+
+function displayQRCode(url) {
+  console.log("=".repeat(80));
+  console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
+  console.log("=".repeat(80));
+  qrcode.generate(url, { small: true }, (qr) => {
+    for (let l of qr.split("\n")) {
+      console.log(" ".repeat(10) + l);
+    }
+  });
+  console.log("=".repeat(80));
+}
+
+function generateWebAuthUrl(publicKey) {
+  const publicKeyBase64 = encodeBase64(publicKey, "base64url");
+  return `https://app.happy.engineering/terminal/connect#key=${publicKeyBase64}`;
+}
+
+async function openBrowser(url) {
   try {
-    const daemonState = await getDaemonState();
-    if (daemonState?.httpPort) {
-      await notifyDaemonSessionStarted(response.id, metadata);
-      logger.debug(`[START] Reported session ${response.id} to daemon`);
+    if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
+      logger.debug("[browser] Headless environment detected, skipping browser open");
+      return false;
     }
+    logger.debug(`[browser] Attempting to open URL: ${url}`);
+    await open$1(url);
+    logger.debug("[browser] Browser opened successfully");
+    return true;
   } catch (error) {
-    logger.debug("[START] Failed to report to daemon (may not be running):", error);
+    logger.debug("[browser] Failed to open browser:", error);
+    return false;
   }
-  extractSDKMetadataAsync(async (sdkMetadata) => {
-    logger.debug("[start] SDK metadata extracted, updating session:", sdkMetadata);
-    try {
-      api.sessionSyncClient(response).updateMetadata((currentMetadata) => ({
-        ...currentMetadata,
-        tools: sdkMetadata.tools,
-        slashCommands: sdkMetadata.slashCommands
-      }));
-      logger.debug("[start] Session metadata updated with SDK capabilities");
-    } catch (error) {
-      logger.debug("[start] Failed to update session metadata:", error);
+}
+
+const AuthSelector = ({ onSelect, onCancel }) => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const options = [
+    {
+      method: "mobile",
+      label: "Mobile App"
+    },
+    {
+      method: "web",
+      label: "Web Browser"
+    }
+  ];
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setSelectedIndex((prev) => Math.max(0, prev - 1));
+    } else if (key.downArrow) {
+      setSelectedIndex((prev) => Math.min(options.length - 1, prev + 1));
+    } else if (key.return) {
+      onSelect(options[selectedIndex].method);
+    } else if (key.escape || key.ctrl && input === "c") {
+      onCancel();
+    } else if (input === "1") {
+      setSelectedIndex(0);
+      onSelect("mobile");
+    } else if (input === "2") {
+      setSelectedIndex(1);
+      onSelect("web");
     }
   });
-  const session = api.sessionSyncClient(response);
-  const logPath = await logger.logFilePathPromise;
-  logger.infoDeveloper(`Session: ${response.id}`);
-  logger.infoDeveloper(`Logs: ${logPath}`);
-  session.updateAgentState((currentState) => ({
-    ...currentState,
-    controlledByUser: options.startingMode !== "remote"
-  }));
-  const caffeinateStarted = startCaffeinate();
-  if (caffeinateStarted) {
-    logger.infoDeveloper("Sleep prevention enabled (macOS)");
-  }
-  const messageQueue = new MessageQueue2((mode) => hashObject(mode));
-  registerHandlers(session);
-  let currentPermissionMode = options.permissionMode;
-  let currentModel = options.model;
-  let currentFallbackModel = void 0;
-  let currentCustomSystemPrompt = void 0;
-  let currentAppendSystemPrompt = void 0;
-  let currentAllowedTools = void 0;
-  let currentDisallowedTools = void 0;
-  session.onUserMessage((message) => {
-    let messagePermissionMode = currentPermissionMode;
-    if (message.meta?.permissionMode) {
-      const validModes = ["default", "acceptEdits", "bypassPermissions", "plan"];
-      if (validModes.includes(message.meta.permissionMode)) {
-        messagePermissionMode = message.meta.permissionMode;
-        currentPermissionMode = messagePermissionMode;
-        logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
-      } else {
-        logger.debug(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
-      }
-    } else {
-      logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
-    }
-    let messageModel = currentModel;
-    if (message.meta?.hasOwnProperty("model")) {
-      messageModel = message.meta.model || void 0;
-      currentModel = messageModel;
-      logger.debug(`[loop] Model updated from user message: ${messageModel || "reset to default"}`);
-    } else {
-      logger.debug(`[loop] User message received with no model override, using current: ${currentModel || "default"}`);
-    }
-    let messageCustomSystemPrompt = currentCustomSystemPrompt;
-    if (message.meta?.hasOwnProperty("customSystemPrompt")) {
-      messageCustomSystemPrompt = message.meta.customSystemPrompt || void 0;
-      currentCustomSystemPrompt = messageCustomSystemPrompt;
-      logger.debug(`[loop] Custom system prompt updated from user message: ${messageCustomSystemPrompt ? "set" : "reset to none"}`);
-    } else {
-      logger.debug(`[loop] User message received with no custom system prompt override, using current: ${currentCustomSystemPrompt ? "set" : "none"}`);
-    }
-    let messageFallbackModel = currentFallbackModel;
-    if (message.meta?.hasOwnProperty("fallbackModel")) {
-      messageFallbackModel = message.meta.fallbackModel || void 0;
-      currentFallbackModel = messageFallbackModel;
-      logger.debug(`[loop] Fallback model updated from user message: ${messageFallbackModel || "reset to none"}`);
-    } else {
-      logger.debug(`[loop] User message received with no fallback model override, using current: ${currentFallbackModel || "none"}`);
-    }
-    let messageAppendSystemPrompt = currentAppendSystemPrompt;
-    if (message.meta?.hasOwnProperty("appendSystemPrompt")) {
-      messageAppendSystemPrompt = message.meta.appendSystemPrompt || void 0;
-      currentAppendSystemPrompt = messageAppendSystemPrompt;
-      logger.debug(`[loop] Append system prompt updated from user message: ${messageAppendSystemPrompt ? "set" : "reset to none"}`);
-    } else {
-      logger.debug(`[loop] User message received with no append system prompt override, using current: ${currentAppendSystemPrompt ? "set" : "none"}`);
-    }
-    let messageAllowedTools = currentAllowedTools;
-    if (message.meta?.hasOwnProperty("allowedTools")) {
-      messageAllowedTools = message.meta.allowedTools || void 0;
-      currentAllowedTools = messageAllowedTools;
-      logger.debug(`[loop] Allowed tools updated from user message: ${messageAllowedTools ? messageAllowedTools.join(", ") : "reset to none"}`);
-    } else {
-      logger.debug(`[loop] User message received with no allowed tools override, using current: ${currentAllowedTools ? currentAllowedTools.join(", ") : "none"}`);
-    }
-    let messageDisallowedTools = currentDisallowedTools;
-    if (message.meta?.hasOwnProperty("disallowedTools")) {
-      messageDisallowedTools = message.meta.disallowedTools || void 0;
-      currentDisallowedTools = messageDisallowedTools;
-      logger.debug(`[loop] Disallowed tools updated from user message: ${messageDisallowedTools ? messageDisallowedTools.join(", ") : "reset to none"}`);
-    } else {
-      logger.debug(`[loop] User message received with no disallowed tools override, using current: ${currentDisallowedTools ? currentDisallowedTools.join(", ") : "none"}`);
-    }
-    const specialCommand = parseSpecialCommand(message.content.text);
-    if (specialCommand.type === "compact") {
-      logger.debug("[start] Detected /compact command");
-      const enhancedMode2 = {
-        permissionMode: messagePermissionMode || "default",
-        model: messageModel,
-        fallbackModel: messageFallbackModel,
-        customSystemPrompt: messageCustomSystemPrompt,
-        appendSystemPrompt: messageAppendSystemPrompt,
-        allowedTools: messageAllowedTools,
-        disallowedTools: messageDisallowedTools
-      };
-      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
-      logger.debugLargeJson("[start] /compact command pushed to queue:", message);
-      return;
-    }
-    if (specialCommand.type === "clear") {
-      logger.debug("[start] Detected /clear command");
-      const enhancedMode2 = {
-        permissionMode: messagePermissionMode || "default",
-        model: messageModel,
-        fallbackModel: messageFallbackModel,
-        customSystemPrompt: messageCustomSystemPrompt,
-        appendSystemPrompt: messageAppendSystemPrompt,
-        allowedTools: messageAllowedTools,
-        disallowedTools: messageDisallowedTools
-      };
-      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
-      logger.debugLargeJson("[start] /compact command pushed to queue:", message);
-      return;
-    }
-    const enhancedMode = {
-      permissionMode: messagePermissionMode || "default",
-      model: messageModel,
-      fallbackModel: messageFallbackModel,
-      customSystemPrompt: messageCustomSystemPrompt,
-      appendSystemPrompt: messageAppendSystemPrompt,
-      allowedTools: messageAllowedTools,
-      disallowedTools: messageDisallowedTools
-    };
-    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,
-    permissionMode: options.permissionMode,
-    startingMode: options.startingMode,
-    messageQueue,
-    api,
-    onModeChange: (newMode) => {
-      session.sendSessionEvent({ type: "switch", mode: newMode });
-      session.updateAgentState((currentState) => ({
-        ...currentState,
-        controlledByUser: newMode === "local"
-      }));
-    },
-    onSessionReady: (sessionInstance) => {
-    },
-    mcpServers: {},
-    session,
-    claudeEnvVars: options.claudeEnvVars,
-    claudeArgs: options.claudeArgs
-  });
-  session.sendSessionDeath();
-  logger.debug("Waiting for socket to flush...");
-  await session.flush();
-  logger.debug("Closing session...");
-  await session.close();
-  stopCaffeinate();
-  logger.debug("Stopped sleep prevention");
-  process.exit(0);
-}
-
-function displayQRCode(url) {
-  console.log("=".repeat(80));
-  console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
-  console.log("=".repeat(80));
-  qrcode.generate(url, { small: true }, (qr) => {
-    for (let l of qr.split("\n")) {
-      console.log(" ".repeat(10) + l);
-    }
-  });
-  console.log("=".repeat(80));
-}
-
-function generateWebAuthUrl(publicKey) {
-  const publicKeyBase64 = encodeBase64(publicKey, "base64url");
-  return `https://app.happy.engineering/terminal/connect#key=${publicKeyBase64}`;
-}
-
-async function openBrowser(url) {
-  try {
-    if (!process.stdout.isTTY || process.env.CI || process.env.HEADLESS) {
-      logger.debug("[browser] Headless environment detected, skipping browser open");
-      return false;
-    }
-    logger.debug(`[browser] Attempting to open URL: ${url}`);
-    await open$1(url);
-    logger.debug("[browser] Browser opened successfully");
-    return true;
-  } catch (error) {
-    logger.debug("[browser] Failed to open browser:", error);
-    return false;
-  }
-}
-
-const AuthSelector = ({ onSelect, onCancel }) => {
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const options = [
-    {
-      method: "mobile",
-      label: "Mobile App"
-    },
-    {
-      method: "web",
-      label: "Web Browser"
-    }
-  ];
-  useInput((input, key) => {
-    if (key.upArrow) {
-      setSelectedIndex((prev) => Math.max(0, prev - 1));
-    } else if (key.downArrow) {
-      setSelectedIndex((prev) => Math.min(options.length - 1, prev + 1));
-    } else if (key.return) {
-      onSelect(options[selectedIndex].method);
-    } else if (key.escape || key.ctrl && input === "c") {
-      onCancel();
-    } else if (input === "1") {
-      setSelectedIndex(0);
-      onSelect("mobile");
-    } else if (input === "2") {
-      setSelectedIndex(1);
-      onSelect("web");
-    }
-  });
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", paddingY: 1 }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "How would you like to authenticate?")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, options.map((option, index) => {
-    const isSelected = selectedIndex === index;
-    return /* @__PURE__ */ React.createElement(Box, { key: option.method, marginY: 0 }, /* @__PURE__ */ React.createElement(Text, { color: isSelected ? "cyan" : "gray" }, isSelected ? "\u203A " : "  ", index + 1, ". ", option.label));
-  })), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Use arrows or 1-2 to select, Enter to confirm")));
-};
-
-async function doAuth() {
-  console.clear();
-  const authMethod = await selectAuthenticationMethod();
-  if (!authMethod) {
-    console.log("\nAuthentication cancelled.\n");
-    return null;
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", paddingY: 1 }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "How would you like to authenticate?")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, options.map((option, index) => {
+    const isSelected = selectedIndex === index;
+    return /* @__PURE__ */ React.createElement(Box, { key: option.method, marginY: 0 }, /* @__PURE__ */ React.createElement(Text, { color: isSelected ? "cyan" : "gray" }, isSelected ? "\u203A " : "  ", index + 1, ". ", option.label));
+  })), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Use arrows or 1-2 to select, Enter to confirm")));
+};
+
+async function doAuth() {
+  console.clear();
+  const authMethod = await selectAuthenticationMethod();
+  if (!authMethod) {
+    console.log("\nAuthentication cancelled.\n");
+    return null;
   }
   const secret = new Uint8Array(randomBytes(32));
   const keypair = tweetnacl.box.keyPair.fromSecretKey(secret);
@@ -4146,6 +4020,8 @@ async function authAndSetupMachineIfNeeded() {
   }
   const settings = await updateSettings(async (s) => {
     if (!s.machineId) {
+      const newMachineId = randomUUID();
+      logger.debug(`[AUTH] No machine ID found, generating new one: ${newMachineId}; We will not create machine on startup since we don't have api client intialized`);
       return {
         ...s,
         machineId: randomUUID()
@@ -4157,101 +4033,33 @@ async function authAndSetupMachineIfNeeded() {
   return { credentials, machineId: settings.machineId };
 }
 
-function startDaemonControlServer({
-  getChildren,
-  stopSession,
-  spawnSession,
-  requestShutdown,
-  onHappySessionWebhook
-}) {
-  return new Promise((resolve) => {
-    const app = fastify({
-      logger: false
-      // We use our own logger
-    });
-    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" };
-    });
-    typed.post("/list", async (request, reply) => {
-      const children = getChildren();
-      logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
-      return { children };
-    });
-    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 };
-    });
-    typed.post("/spawn-session", {
-      schema: {
-        body: z$1.object({
-          directory: z$1.string(),
-          sessionId: z$1.string().optional()
-        })
-      }
-    }, 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" };
-      }
-    });
-    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;
-      }
-      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");
-        }
-      });
-    });
-  });
-}
-
+function spawnHappyCLI(args, options = {}) {
+  const projectRoot = projectPath();
+  const entrypoint = join(projectRoot, "dist", "index.mjs");
+  let directory;
+  if ("cwd" in options) {
+    directory = options.cwd;
+  } else {
+    directory = process.cwd();
+  }
+  const fullCommand = `happy ${args.join(" ")}`;
+  logger.debug(`[DAEMON RUN] Spawning: ${fullCommand} in ${directory}`);
+  const nodeArgs = [
+    "--no-warnings",
+    "--no-deprecation",
+    entrypoint,
+    ...args
+  ];
+  return spawn$1("node", nodeArgs, options);
+}
+
+const initialMachineMetadata = {
+  host: os.hostname(),
+  platform: os.platform(),
+  happyCliVersion: packageJson.version,
+  homeDir: os.homedir(),
+  happyHomeDir: configuration.happyHomeDir
+};
 async function startDaemon() {
   logger.debug("[DAEMON RUN] Starting daemon process...");
   logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
@@ -4260,6 +4068,7 @@ async function startDaemon() {
     try {
       process.kill(runningDaemon.pid, 0);
       logger.debug("[DAEMON RUN] Daemon already running");
+      console.log(`Daemon already running (PID: ${runningDaemon.pid})`);
       process.exit(0);
     } catch {
       logger.debug("[DAEMON RUN] Stale state found, cleaning up");
@@ -4314,9 +4123,7 @@ async function startDaemon() {
           "--started-by",
           "daemon"
         ];
-        const fullCommand = `${happyBinPath} ${args.join(" ")}`;
-        logger.debug(`[DAEMON RUN] Spawning: ${fullCommand} in ${directory}`);
-        const happyProcess = spawn$1(happyBinPath, args, {
+        const happyProcess = spawnHappyCLI(args, {
           cwd: directory,
           detached: true,
           // Sessions stay alive when daemon stops
@@ -4421,13 +4228,6 @@ async function startDaemon() {
     };
     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,
@@ -4435,9 +4235,9 @@ async function startDaemon() {
       startedAt: Date.now()
     };
     const api = new ApiClient(credentials.token, credentials.secret);
-    const machine = await api.createOrReturnExistingAsIs({
+    const machine = await api.createMachineOrGetExistingAsIs({
       machineId,
-      metadata: initialMetadata,
+      metadata: initialMachineMetadata,
       daemonState: initialDaemonState
     });
     logger.debug(`[DAEMON RUN] Machine registered: ${machine.id}`);
@@ -4502,6 +4302,247 @@ async function startDaemon() {
   }
 }
 
+async function start(credentials, options = {}) {
+  const workingDirectory = process.cwd();
+  const sessionTag = randomUUID();
+  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();
+  let machineId = settings?.machineId;
+  if (!machineId) {
+    console.error(`[START] No machine ID found in settings, which is unexepcted since authAndSetupMachineIfNeeded should have created it, using 'unknown' id instead`);
+    machineId = "unknown";
+  }
+  logger.debug(`Using machineId: ${machineId}`);
+  let metadata = {
+    path: workingDirectory,
+    host: os$1.hostname(),
+    version: packageJson.version,
+    os: os$1.platform(),
+    machineId,
+    homeDir: os$1.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}`);
+  await api.createMachineOrGetExistingAsIs({
+    machineId,
+    metadata: initialMachineMetadata
+  });
+  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.sessionSyncClient(response).updateMetadata((currentMetadata) => ({
+        ...currentMetadata,
+        tools: sdkMetadata.tools,
+        slashCommands: sdkMetadata.slashCommands
+      }));
+      logger.debug("[start] Session metadata updated with SDK capabilities");
+    } catch (error) {
+      logger.debug("[start] Failed to update session metadata:", error);
+    }
+  });
+  const session = api.sessionSyncClient(response);
+  const logPath = await logger.logFilePathPromise;
+  logger.infoDeveloper(`Session: ${response.id}`);
+  logger.infoDeveloper(`Logs: ${logPath}`);
+  session.updateAgentState((currentState) => ({
+    ...currentState,
+    controlledByUser: options.startingMode !== "remote"
+  }));
+  const caffeinateStarted = startCaffeinate();
+  if (caffeinateStarted) {
+    logger.infoDeveloper("Sleep prevention enabled (macOS)");
+  }
+  const messageQueue = new MessageQueue2((mode) => hashObject(mode));
+  registerHandlers(session);
+  let currentPermissionMode = options.permissionMode;
+  let currentModel = options.model;
+  let currentFallbackModel = void 0;
+  let currentCustomSystemPrompt = void 0;
+  let currentAppendSystemPrompt = void 0;
+  let currentAllowedTools = void 0;
+  let currentDisallowedTools = void 0;
+  session.onUserMessage((message) => {
+    let messagePermissionMode = currentPermissionMode;
+    if (message.meta?.permissionMode) {
+      const validModes = ["default", "acceptEdits", "bypassPermissions", "plan"];
+      if (validModes.includes(message.meta.permissionMode)) {
+        messagePermissionMode = message.meta.permissionMode;
+        currentPermissionMode = messagePermissionMode;
+        logger.debug(`[loop] Permission mode updated from user message to: ${currentPermissionMode}`);
+      } else {
+        logger.debug(`[loop] Invalid permission mode received: ${message.meta.permissionMode}`);
+      }
+    } else {
+      logger.debug(`[loop] User message received with no permission mode override, using current: ${currentPermissionMode}`);
+    }
+    let messageModel = currentModel;
+    if (message.meta?.hasOwnProperty("model")) {
+      messageModel = message.meta.model || void 0;
+      currentModel = messageModel;
+      logger.debug(`[loop] Model updated from user message: ${messageModel || "reset to default"}`);
+    } else {
+      logger.debug(`[loop] User message received with no model override, using current: ${currentModel || "default"}`);
+    }
+    let messageCustomSystemPrompt = currentCustomSystemPrompt;
+    if (message.meta?.hasOwnProperty("customSystemPrompt")) {
+      messageCustomSystemPrompt = message.meta.customSystemPrompt || void 0;
+      currentCustomSystemPrompt = messageCustomSystemPrompt;
+      logger.debug(`[loop] Custom system prompt updated from user message: ${messageCustomSystemPrompt ? "set" : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no custom system prompt override, using current: ${currentCustomSystemPrompt ? "set" : "none"}`);
+    }
+    let messageFallbackModel = currentFallbackModel;
+    if (message.meta?.hasOwnProperty("fallbackModel")) {
+      messageFallbackModel = message.meta.fallbackModel || void 0;
+      currentFallbackModel = messageFallbackModel;
+      logger.debug(`[loop] Fallback model updated from user message: ${messageFallbackModel || "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no fallback model override, using current: ${currentFallbackModel || "none"}`);
+    }
+    let messageAppendSystemPrompt = currentAppendSystemPrompt;
+    if (message.meta?.hasOwnProperty("appendSystemPrompt")) {
+      messageAppendSystemPrompt = message.meta.appendSystemPrompt || void 0;
+      currentAppendSystemPrompt = messageAppendSystemPrompt;
+      logger.debug(`[loop] Append system prompt updated from user message: ${messageAppendSystemPrompt ? "set" : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no append system prompt override, using current: ${currentAppendSystemPrompt ? "set" : "none"}`);
+    }
+    let messageAllowedTools = currentAllowedTools;
+    if (message.meta?.hasOwnProperty("allowedTools")) {
+      messageAllowedTools = message.meta.allowedTools || void 0;
+      currentAllowedTools = messageAllowedTools;
+      logger.debug(`[loop] Allowed tools updated from user message: ${messageAllowedTools ? messageAllowedTools.join(", ") : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no allowed tools override, using current: ${currentAllowedTools ? currentAllowedTools.join(", ") : "none"}`);
+    }
+    let messageDisallowedTools = currentDisallowedTools;
+    if (message.meta?.hasOwnProperty("disallowedTools")) {
+      messageDisallowedTools = message.meta.disallowedTools || void 0;
+      currentDisallowedTools = messageDisallowedTools;
+      logger.debug(`[loop] Disallowed tools updated from user message: ${messageDisallowedTools ? messageDisallowedTools.join(", ") : "reset to none"}`);
+    } else {
+      logger.debug(`[loop] User message received with no disallowed tools override, using current: ${currentDisallowedTools ? currentDisallowedTools.join(", ") : "none"}`);
+    }
+    const specialCommand = parseSpecialCommand(message.content.text);
+    if (specialCommand.type === "compact") {
+      logger.debug("[start] Detected /compact command");
+      const enhancedMode2 = {
+        permissionMode: messagePermissionMode || "default",
+        model: messageModel,
+        fallbackModel: messageFallbackModel,
+        customSystemPrompt: messageCustomSystemPrompt,
+        appendSystemPrompt: messageAppendSystemPrompt,
+        allowedTools: messageAllowedTools,
+        disallowedTools: messageDisallowedTools
+      };
+      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
+      logger.debugLargeJson("[start] /compact command pushed to queue:", message);
+      return;
+    }
+    if (specialCommand.type === "clear") {
+      logger.debug("[start] Detected /clear command");
+      const enhancedMode2 = {
+        permissionMode: messagePermissionMode || "default",
+        model: messageModel,
+        fallbackModel: messageFallbackModel,
+        customSystemPrompt: messageCustomSystemPrompt,
+        appendSystemPrompt: messageAppendSystemPrompt,
+        allowedTools: messageAllowedTools,
+        disallowedTools: messageDisallowedTools
+      };
+      messageQueue.pushIsolateAndClear(specialCommand.originalMessage || message.content.text, enhancedMode2);
+      logger.debugLargeJson("[start] /compact command pushed to queue:", message);
+      return;
+    }
+    const enhancedMode = {
+      permissionMode: messagePermissionMode || "default",
+      model: messageModel,
+      fallbackModel: messageFallbackModel,
+      customSystemPrompt: messageCustomSystemPrompt,
+      appendSystemPrompt: messageAppendSystemPrompt,
+      allowedTools: messageAllowedTools,
+      disallowedTools: messageDisallowedTools
+    };
+    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,
+    permissionMode: options.permissionMode,
+    startingMode: options.startingMode,
+    messageQueue,
+    api,
+    onModeChange: (newMode) => {
+      session.sendSessionEvent({ type: "switch", mode: newMode });
+      session.updateAgentState((currentState) => ({
+        ...currentState,
+        controlledByUser: newMode === "local"
+      }));
+    },
+    onSessionReady: (sessionInstance) => {
+    },
+    mcpServers: {},
+    session,
+    claudeEnvVars: options.claudeEnvVars,
+    claudeArgs: options.claudeArgs
+  });
+  session.sendSessionDeath();
+  logger.debug("Waiting for socket to flush...");
+  await session.flush();
+  logger.debug("Closing session...");
+  await session.close();
+  stopCaffeinate();
+  logger.debug("Stopped sleep prevention");
+  process.exit(0);
+}
+
 function trimIdent(text) {
   const lines = text.split("\n");
   while (lines.length > 0 && lines[0].trim() === "") {
@@ -4559,10 +4600,10 @@ async function install$1() {
                 <true/>
                 
                 <key>StandardErrorPath</key>
-                <string>${os$1.homedir()}/.happy/daemon.err</string>
+                <string>${os.homedir()}/.happy/daemon.err</string>
                 
                 <key>StandardOutPath</key>
-                <string>${os$1.homedir()}/.happy/daemon.log</string>
+                <string>${os.homedir()}/.happy/daemon.log</string>
                 
                 <key>WorkingDirectory</key>
                 <string>/tmp</string>
@@ -4733,7 +4774,7 @@ async function handleAuthLogin(args) {
     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(`  Host: ${os$1.hostname()}`));
       console.log(chalk.gray(`  Use 'happy auth login --force' to re-authenticate`));
       return;
     } else if (existingCreds && !settings?.machineId) {
@@ -4802,7 +4843,7 @@ async function handleAuthShowBackup() {
   console.log("");
   console.log(chalk.cyan("Machine Information:"));
   console.log(`  Machine ID: ${settings?.machineId || "not set"}`);
-  console.log(`  Host: ${os.hostname()}`);
+  console.log(`  Host: ${os$1.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"));
@@ -4827,7 +4868,7 @@ async function handleAuthStatus() {
   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()}`));
+    console.log(chalk.gray(`  Host: ${os$1.hostname()}`));
   } else {
     console.log(chalk.yellow("\u26A0\uFE0F  Machine not registered"));
     console.log(chalk.gray('  Run "happy auth login --force" to fix this'));
@@ -4847,6 +4888,34 @@ async function handleAuthStatus() {
   }
 }
 
+const DaemonPrompt = ({ onSelect }) => {
+  const [selectedIndex, setSelectedIndex] = useState(0);
+  const options = [
+    { value: true, label: "Yes (recommended)", key: "Y" },
+    { value: false, label: "No", key: "N" }
+  ];
+  useInput((input, key) => {
+    const upperInput = input.toUpperCase();
+    if (key.upArrow || key.leftArrow) {
+      setSelectedIndex(0);
+    } else if (key.downArrow || key.rightArrow) {
+      setSelectedIndex(1);
+    } else if (key.return) {
+      onSelect(options[selectedIndex].value);
+    } else if (upperInput === "Y") {
+      onSelect(true);
+    } else if (upperInput === "N") {
+      onSelect(false);
+    } else if (key.escape || key.ctrl && input === "c") {
+      onSelect(false);
+    }
+  });
+  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, "\u{1F680} Happy Daemon Setup")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "\u{1F4F1} Happy can run a background service that allows you to:"), /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "  \u2022 Spawn new conversations from your phone"), /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "  \u2022 Continue closed conversations remotely"), /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "  \u2022 Work with Claude while your computer has internet")), /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "Would you like Happy to start this service automatically?")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, options.map((option, index) => {
+    const isSelected = selectedIndex === index;
+    return /* @__PURE__ */ React.createElement(Box, { key: option.key }, /* @__PURE__ */ React.createElement(Text, { color: isSelected ? "green" : "gray" }, isSelected ? "\u203A " : "  ", "[", option.key, "] ", option.label));
+  })), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Press Y/N or use arrows + Enter to select")));
+};
+
 (async () => {
   const args = process.argv.slice(2);
   logger.debug("Starting happy CLI with args: ", process.argv);
@@ -4923,8 +4992,7 @@ async function handleAuthStatus() {
       }
       return;
     } else if (daemonSubcommand === "start") {
-      const happyBinPath = join(projectPath(), "bin", "happy.mjs");
-      const child = spawn$1(happyBinPath, ["daemon", "start-sync"], {
+      const child = spawnHappyCLI(["daemon", "start-sync"], {
         detached: true,
         stdio: "ignore",
         env: process.env
@@ -5114,36 +5182,35 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
     }
     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,
-        output: process.stdout
-      });
-      console.log(chalk.cyan("\n\u{1F4F1} Happy can run a background service that allows you to:"));
-      console.log(chalk.cyan("  \u2022 Spawn new conversations from your phone"));
-      console.log(chalk.cyan("  \u2022 Continue closed conversations remotely"));
-      console.log(chalk.cyan("  \u2022 Work with Claude while your computer has internet\n"));
-      const answer = await new Promise((resolve) => {
-        rl.question(chalk.green("Would you like Happy to start this service automatically? (recommended) [Y/n]: "), resolve);
+      const shouldAutoStart = await new Promise((resolve) => {
+        let hasResolved = false;
+        const onSelect = (autoStart) => {
+          if (!hasResolved) {
+            hasResolved = true;
+            app.unmount();
+            resolve(autoStart);
+          }
+        };
+        const app = render(React.createElement(DaemonPrompt, { onSelect }), {
+          exitOnCtrlC: false,
+          patchConsole: false
+        });
       });
-      rl.close();
-      const shouldAutoStart = answer.toLowerCase() !== "n";
       settings = await updateSettings((settings2) => ({
         ...settings2,
         daemonAutoStartWhenRunningHappy: shouldAutoStart
       }));
       if (shouldAutoStart) {
-        console.log(chalk.green("\u2713 Happy will start the background service automatically"));
+        console.log(chalk.green("\n\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"));
+        console.log(chalk.yellow("\n  You can enable this later by running: happy daemon install"));
       }
     }
     if (settings && settings.daemonAutoStartWhenRunningHappy) {
       logger.debug("Starting Happy background service...");
       if (!await isDaemonRunning()) {
-        const happyBinPath = join(projectPath(), "bin", "happy.mjs");
-        const daemonProcess = spawn$1(happyBinPath, ["daemon", "start-sync"], {
+        const daemonProcess = spawnHappyCLI(["daemon", "start-sync"], {
           detached: true,
           stdio: "ignore",
           env: process.env