happy-coder 0.1.9 → 0.1.10

package/dist/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var chalk = require('chalk');
-var types = require('./types-mykDX2xe.cjs');
+var types = require('./types-B2JzqUiU.cjs');
 var node_crypto = require('node:crypto');
 var claudeCode = require('@anthropic-ai/claude-code');
 var node_fs = require('node:fs');
@@ -17,12 +17,18 @@ var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp
 var z = require('zod');
 var node_https = require('node:https');
 var net = require('node:net');
+var child_process = require('child_process');
+var util = require('util');
+var promises$1 = require('fs/promises');
+var crypto = require('crypto');
+var path = require('path');
 var tweetnacl = require('tweetnacl');
 var axios = require('axios');
 var qrcode = require('qrcode-terminal');
-require('fs');
-require('node:events');
-require('socket.io-client');
+var node_events = require('node:events');
+var socket_ioClient = require('socket.io-client');
+var os$1 = require('os');
+var fs = require('fs');
 require('expo-server-sdk');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -573,14 +579,14 @@ function createSessionScanner(opts) {
           processedMessages.add(key);
           types.logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
           types.logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
-          if (parsed.data.type === "user" && typeof parsed.data.message.content === "string") {
+          if (parsed.data.type === "user" && typeof parsed.data.message.content === "string" && parsed.data.isSidechain !== true && parsed.data.isMeta !== true) {
             const currentCounter = seenRemoteUserMessageCounters.get(parsed.data.message.content);
             if (currentCounter && currentCounter > 0) {
               seenRemoteUserMessageCounters.set(parsed.data.message.content, currentCounter - 1);
               continue;
             }
           }
-          opts.onMessage(parsed.data);
+          opts.onMessage(message);
         } catch (e) {
           continue;
         }
@@ -883,7 +889,7 @@ class InterruptController {
   }
 }
 
-var version = "0.1.9";
+var version = "0.1.10";
 var packageJson = {
 	version: version};
 
@@ -1034,12 +1040,235 @@ async function startAnthropicActivityProxy(onClaudeActivity) {
   };
 }
 
+const execAsync = util.promisify(child_process.exec);
+function registerHandlers(session, interruptController, permissionCallbacks) {
+  session.setHandler("abort", async () => {
+    types.logger.info("Abort request - interrupting Claude");
+    await interruptController.interrupt();
+  });
+  if (permissionCallbacks) {
+    session.setHandler("permission", async (message) => {
+      types.logger.info("Permission response" + JSON.stringify(message));
+      const id = message.id;
+      const resolve = permissionCallbacks.requests.get(id);
+      if (resolve) {
+        if (!message.approved) {
+          types.logger.debug("Permission denied, interrupting Claude");
+          await interruptController.interrupt();
+        }
+        resolve({ approved: message.approved, reason: message.reason });
+        permissionCallbacks.requests.delete(id);
+      } else {
+        types.logger.info("Permission request stale, likely timed out");
+        return;
+      }
+      session.updateAgentState((currentState) => {
+        let r = { ...currentState.requests };
+        delete r[id];
+        return {
+          ...currentState,
+          requests: r
+        };
+      });
+    });
+  }
+  session.setHandler("bash", async (data) => {
+    types.logger.info("Shell command request:", data.command);
+    try {
+      const options = {
+        cwd: data.cwd,
+        timeout: data.timeout || 3e4
+        // Default 30 seconds timeout
+      };
+      const { stdout, stderr } = await execAsync(data.command, options);
+      return {
+        success: true,
+        stdout: stdout || "",
+        stderr: stderr || "",
+        exitCode: 0
+      };
+    } catch (error) {
+      const execError = error;
+      if (execError.code === "ETIMEDOUT" || execError.killed) {
+        return {
+          success: false,
+          stdout: execError.stdout || "",
+          stderr: execError.stderr || "",
+          exitCode: typeof execError.code === "number" ? execError.code : -1,
+          error: "Command timed out"
+        };
+      }
+      return {
+        success: false,
+        stdout: execError.stdout || "",
+        stderr: execError.stderr || execError.message || "Command failed",
+        exitCode: typeof execError.code === "number" ? execError.code : 1,
+        error: execError.message || "Command failed"
+      };
+    }
+  });
+  session.setHandler("readFile", async (data) => {
+    types.logger.info("Read file request:", data.path);
+    try {
+      const buffer = await promises$1.readFile(data.path);
+      const content = buffer.toString("base64");
+      return { success: true, content };
+    } catch (error) {
+      types.logger.debug("Failed to read file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
+    }
+  });
+  session.setHandler("writeFile", async (data) => {
+    types.logger.info("Write file request:", data.path);
+    try {
+      if (data.expectedHash !== null && data.expectedHash !== void 0) {
+        try {
+          const existingBuffer = await promises$1.readFile(data.path);
+          const existingHash = crypto.createHash("sha256").update(existingBuffer).digest("hex");
+          if (existingHash !== data.expectedHash) {
+            return {
+              success: false,
+              error: `File hash mismatch. Expected: ${data.expectedHash}, Actual: ${existingHash}`
+            };
+          }
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+          return {
+            success: false,
+            error: "File does not exist but hash was provided"
+          };
+        }
+      } else {
+        try {
+          await promises$1.stat(data.path);
+          return {
+            success: false,
+            error: "File already exists but was expected to be new"
+          };
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+      const buffer = Buffer.from(data.content, "base64");
+      await promises$1.writeFile(data.path, buffer);
+      const hash = crypto.createHash("sha256").update(buffer).digest("hex");
+      return { success: true, hash };
+    } catch (error) {
+      types.logger.debug("Failed to write file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
+    }
+  });
+  session.setHandler("listDirectory", async (data) => {
+    types.logger.info("List directory request:", data.path);
+    try {
+      const entries = await promises$1.readdir(data.path, { withFileTypes: true });
+      const directoryEntries = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = path.join(data.path, entry.name);
+          let type = "other";
+          let size;
+          let modified;
+          if (entry.isDirectory()) {
+            type = "directory";
+          } else if (entry.isFile()) {
+            type = "file";
+          }
+          try {
+            const stats = await promises$1.stat(fullPath);
+            size = stats.size;
+            modified = stats.mtime.getTime();
+          } catch (error) {
+            types.logger.debug(`Failed to stat ${fullPath}:`, error);
+          }
+          return {
+            name: entry.name,
+            type,
+            size,
+            modified
+          };
+        })
+      );
+      directoryEntries.sort((a, b) => {
+        if (a.type === "directory" && b.type !== "directory") return -1;
+        if (a.type !== "directory" && b.type === "directory") return 1;
+        return a.name.localeCompare(b.name);
+      });
+      return { success: true, entries: directoryEntries };
+    } catch (error) {
+      types.logger.debug("Failed to list directory:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
+    }
+  });
+  session.setHandler("getDirectoryTree", async (data) => {
+    types.logger.info("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    async function buildTree(path$1, name, currentDepth) {
+      try {
+        const stats = await promises$1.stat(path$1);
+        const node = {
+          name,
+          path: path$1,
+          type: stats.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.getTime()
+        };
+        if (stats.isDirectory() && currentDepth < data.maxDepth) {
+          const entries = await promises$1.readdir(path$1, { withFileTypes: true });
+          const children = [];
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (entry.isSymbolicLink()) {
+                types.logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
+                return;
+              }
+              const childPath = path.join(path$1, entry.name);
+              const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
+              if (childNode) {
+                children.push(childNode);
+              }
+            })
+          );
+          children.sort((a, b) => {
+            if (a.type === "directory" && b.type !== "directory") return -1;
+            if (a.type !== "directory" && b.type === "directory") return 1;
+            return a.name.localeCompare(b.name);
+          });
+          node.children = children;
+        }
+        return node;
+      } catch (error) {
+        types.logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
+        return null;
+      }
+    }
+    try {
+      if (data.maxDepth < 0) {
+        return { success: false, error: "maxDepth must be non-negative" };
+      }
+      const baseName = data.path === "/" ? "/" : data.path.split("/").pop() || data.path;
+      const tree = await buildTree(data.path, baseName, 0);
+      if (!tree) {
+        return { success: false, error: "Failed to access the specified path" };
+      }
+      return { success: true, tree };
+    } catch (error) {
+      types.logger.debug("Failed to get directory tree:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
+    }
+  });
+}
+
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = node_crypto.randomUUID();
   const api = new types.ApiClient(credentials.token, credentials.secret);
   let state = {};
-  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version };
+  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version, os: os.platform() };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   types.logger.debug(`Session created: ${response.id}`);
   const session = api.session(response);
@@ -1062,7 +1291,7 @@ async function start(credentials, options = {}) {
   process.env.HTTPS_PROXY = antropicActivityProxy.url;
   types.logger.debug(`[AnthropicProxy] Set HTTP_PROXY and HTTPS_PROXY to ${antropicActivityProxy.url}`);
   const logPath = await types.logger.logFilePathPromise;
-  types.logger.info(`Session: ${response.id}`);
+  types.logger.infoDeveloper(`Session: ${response.id}`);
   types.logger.infoDeveloper(`Logs: ${logPath}`);
   const interruptController = new InterruptController();
   let requests = /* @__PURE__ */ new Map();
@@ -1116,29 +1345,7 @@ async function start(credentials, options = {}) {
     promise.then(() => clearTimeout(timeout)).catch(() => clearTimeout(timeout));
     return promise;
   });
-  session.setHandler("permission", (message) => {
-    types.logger.info("Permission response" + JSON.stringify(message));
-    const id = message.id;
-    const resolve = requests.get(id);
-    if (resolve) {
-      resolve({ approved: message.approved, reason: message.reason });
-    } else {
-      types.logger.info("Permission request stale, likely timed out");
-      return;
-    }
-    session.updateAgentState((currentState) => {
-      let r = { ...currentState.requests };
-      delete r[id];
-      return {
-        ...currentState,
-        requests: r
-      };
-    });
-  });
-  session.setHandler("abort", async () => {
-    types.logger.info("Abort request - interrupting Claude");
-    await interruptController.interrupt();
-  });
+  registerHandlers(session, interruptController, { requests });
   const onAssistantResult = async (result) => {
     try {
       const summary = "result" in result && result.result ? result.result.substring(0, 100) + (result.result.length > 100 ? "..." : "") : "";
@@ -1176,12 +1383,32 @@ async function start(credentials, options = {}) {
   });
   clearInterval(pingInterval);
   if (antropicActivityProxy) {
-    types.logger.info("[AnthropicProxy] Shutting down activity monitoring proxy");
+    types.logger.debug("[AnthropicProxy] Shutting down thinking activity monitoring proxy");
     antropicActivityProxy.cleanup();
   }
   process.exit(0);
 }
 
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!node_fs.existsSync(types.configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await promises.readFile(types.configuration.settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
+}
+async function writeSettings(settings) {
+  if (!node_fs.existsSync(types.configuration.happyDir)) {
+    await promises.mkdir(types.configuration.happyDir, { recursive: true });
+  }
+  await promises.writeFile(types.configuration.settingsFile, JSON.stringify(settings, null, 2));
+}
 const credentialsSchema = z__namespace.object({
   secret: z__namespace.string().base64(),
   token: z__namespace.string()
@@ -1283,6 +1510,355 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
   return decrypted;
 }
 
+class ApiDaemonSession extends node_events.EventEmitter {
+  socket;
+  machineIdentity;
+  keepAliveInterval = null;
+  token;
+  secret;
+  constructor(token, secret, machineIdentity) {
+    super();
+    this.token = token;
+    this.secret = secret;
+    this.machineIdentity = machineIdentity;
+    const socket = socket_ioClient.io(types.configuration.serverUrl, {
+      auth: {
+        token: this.token,
+        clientType: "machine-scoped",
+        machineId: this.machineIdentity.machineId
+      },
+      path: "/v1/user-machine-daemon",
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      transports: ["websocket"],
+      withCredentials: true,
+      autoConnect: false
+    });
+    socket.on("connect", () => {
+      types.logger.debug("[DAEMON] Connected to server");
+      this.emit("connected");
+      socket.emit("machine-connect", {
+        token: this.token,
+        machineIdentity: types.encodeBase64(types.encrypt(this.machineIdentity, this.secret))
+      });
+      this.startKeepAlive();
+    });
+    socket.on("disconnect", () => {
+      types.logger.debug("[DAEMON] Disconnected from server");
+      this.emit("disconnected");
+      this.stopKeepAlive();
+    });
+    socket.on("spawn-session", async (encryptedData, callback) => {
+      let requestData;
+      try {
+        requestData = types.decrypt(types.decodeBase64(encryptedData), this.secret);
+        types.logger.debug("[DAEMON] Received spawn-session request", requestData);
+        const args = [
+          "--directory",
+          requestData.directory,
+          "--happy-starting-mode",
+          requestData.startingMode
+        ];
+        if (requestData.metadata) {
+          args.push("--metadata", requestData.metadata);
+        }
+        if (requestData.startingMode === "interactive" && process.platform === "darwin") {
+          const script = `
+            tell application "Terminal"
+              activate
+              do script "cd ${requestData.directory} && happy ${args.join(" ")}"
+            end tell
+          `;
+          child_process.spawn("osascript", ["-e", script], { detached: true });
+        } else {
+          const child = child_process.spawn("happy", args, {
+            detached: true,
+            stdio: "ignore",
+            cwd: requestData.directory
+          });
+          child.unref();
+        }
+        const result = { success: true };
+        socket.emit("session-spawn-result", {
+          requestId: requestData.requestId,
+          result: types.encodeBase64(types.encrypt(result, this.secret))
+        });
+        callback(types.encodeBase64(types.encrypt({ success: true }, this.secret)));
+      } catch (error) {
+        types.logger.debug("[DAEMON] Failed to spawn session", error);
+        const errorResult = {
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+        socket.emit("session-spawn-result", {
+          requestId: requestData?.requestId || "",
+          result: types.encodeBase64(types.encrypt(errorResult, this.secret))
+        });
+        callback(types.encodeBase64(types.encrypt(errorResult, this.secret)));
+      }
+    });
+    socket.on("daemon-command", (data) => {
+      switch (data.command) {
+        case "shutdown":
+          this.shutdown();
+          break;
+        case "status":
+          this.emit("status-request");
+          break;
+      }
+    });
+    this.socket = socket;
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveInterval = setInterval(() => {
+      this.socket.volatile.emit("machine-alive", {
+        time: Date.now()
+      });
+    }, 2e4);
+  }
+  stopKeepAlive() {
+    if (this.keepAliveInterval) {
+      clearInterval(this.keepAliveInterval);
+      this.keepAliveInterval = null;
+    }
+  }
+  connect() {
+    this.socket.connect();
+  }
+  shutdown() {
+    this.stopKeepAlive();
+    this.socket.close();
+    this.emit("shutdown");
+  }
+}
+
+const DAEMON_PID_FILE = path.join(os$1.homedir(), ".happy", "daemon-pid");
+async function startDaemon() {
+  if (isDaemonRunning()) {
+    console.log("Happy daemon is already running");
+    process.exit(0);
+  }
+  types.logger.info("Happy CLI daemon started successfully");
+  writePidFile();
+  process.on("SIGINT", stopDaemon);
+  process.on("SIGTERM", stopDaemon);
+  process.on("exit", stopDaemon);
+  try {
+    const settings = await readSettings() || { onboardingCompleted: false };
+    if (!settings.machineId) {
+      settings.machineId = crypto.randomUUID();
+      settings.machineHost = os$1.hostname();
+      await writeSettings(settings);
+    }
+    const machineIdentity = {
+      machineId: settings.machineId,
+      machineHost: settings.machineHost || os$1.hostname(),
+      platform: process.platform,
+      version: process.env.npm_package_version || "unknown"
+    };
+    let credentials = await readCredentials();
+    if (!credentials) {
+      types.logger.debug("[DAEMON] No credentials found, running auth");
+      await doAuth();
+      credentials = await readCredentials();
+      if (!credentials) {
+        throw new Error("Failed to authenticate");
+      }
+    }
+    const { token, secret } = credentials;
+    const daemon = new ApiDaemonSession(token, secret, machineIdentity);
+    daemon.on("connected", () => {
+      types.logger.debug("[DAEMON] Successfully connected to server");
+    });
+    daemon.on("disconnected", () => {
+      types.logger.debug("[DAEMON] Disconnected from server");
+    });
+    daemon.on("shutdown", () => {
+      types.logger.debug("[DAEMON] Shutdown requested");
+      stopDaemon();
+      process.exit(0);
+    });
+    daemon.connect();
+    setInterval(() => {
+    }, 1e3);
+  } catch (error) {
+    types.logger.debug("[DAEMON] Failed to start daemon", error);
+    stopDaemon();
+    process.exit(1);
+  }
+  process.on("SIGINT", () => process.exit(0));
+  process.on("SIGTERM", () => process.exit(0));
+  process.on("exit", () => process.exit(0));
+  while (true) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  }
+}
+function isDaemonRunning() {
+  try {
+    if (!fs.existsSync(DAEMON_PID_FILE)) {
+      console.log("No PID file found");
+      return false;
+    }
+    const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      console.log("Process not running", error);
+      fs.unlinkSync(DAEMON_PID_FILE);
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+function writePidFile() {
+  const happyDir = path.join(os$1.homedir(), ".happy");
+  if (!fs.existsSync(happyDir)) {
+    fs.mkdirSync(happyDir, { recursive: true });
+  }
+  fs.writeFileSync(DAEMON_PID_FILE, process.pid.toString());
+}
+function stopDaemon() {
+  try {
+    if (fs.existsSync(DAEMON_PID_FILE)) {
+      types.logger.debug("[DAEMON] Stopping daemon");
+      process.kill(parseInt(fs.readFileSync(DAEMON_PID_FILE, "utf-8")), "SIGTERM");
+      fs.unlinkSync(DAEMON_PID_FILE);
+    }
+  } catch (error) {
+    types.logger.debug("[DAEMON] Error cleaning up PID file", error);
+  }
+}
+
+function trimIdent(text) {
+  const lines = text.split("\n");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  const minSpaces = lines.reduce((min, line) => {
+    if (line.trim() === "") {
+      return min;
+    }
+    const leadingSpaces = line.match(/^\s*/)[0].length;
+    return Math.min(min, leadingSpaces);
+  }, Infinity);
+  const trimmedLines = lines.map((line) => line.slice(minSpaces));
+  return trimmedLines.join("\n");
+}
+
+const PLIST_LABEL$1 = "com.happy-cli.daemon";
+const PLIST_FILE$1 = `/Library/LaunchDaemons/${PLIST_LABEL$1}.plist`;
+const USER_HOME = process.env.HOME || process.env.USERPROFILE;
+async function install$1() {
+  try {
+    if (fs.existsSync(PLIST_FILE$1)) {
+      types.logger.info("Daemon plist already exists. Uninstalling first...");
+      child_process.execSync(`launchctl unload ${PLIST_FILE$1}`, { stdio: "inherit" });
+    }
+    const happyPath = process.argv[0];
+    const scriptPath = process.argv[1];
+    const plistContent = trimIdent(`
+            <?xml version="1.0" encoding="UTF-8"?>
+            <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+            <plist version="1.0">
+            <dict>
+                <key>Label</key>
+                <string>${PLIST_LABEL$1}</string>
+                
+                <key>ProgramArguments</key>
+                <array>
+                    <string>${happyPath}</string>
+                    <string>${scriptPath}</string>
+                    <string>happy-daemon</string>
+                </array>
+                
+                <key>EnvironmentVariables</key>
+                <dict>
+                    <key>HAPPY_DAEMON_MODE</key>
+                    <string>true</string>
+                </dict>
+                
+                <key>RunAtLoad</key>
+                <true/>
+                
+                <key>KeepAlive</key>
+                <true/>
+                
+                <key>StandardErrorPath</key>
+                <string>${USER_HOME}/.happy/daemon.err</string>
+                
+                <key>StandardOutPath</key>
+                <string>${USER_HOME}/.happy/daemon.log</string>
+                
+                <key>WorkingDirectory</key>
+                <string>/tmp</string>
+            </dict>
+            </plist>
+        `);
+    fs.writeFileSync(PLIST_FILE$1, plistContent);
+    fs.chmodSync(PLIST_FILE$1, 420);
+    types.logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
+    child_process.execSync(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
+    types.logger.info("Daemon installed and started successfully");
+    types.logger.info("Check logs at ~/.happy/daemon.log");
+  } catch (error) {
+    types.logger.debug("Failed to install daemon:", error);
+    throw error;
+  }
+}
+
+async function install() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon installation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon installation requires sudo privileges. Please run with sudo.");
+  }
+  types.logger.info("Installing Happy CLI daemon for macOS...");
+  await install$1();
+}
+
+const PLIST_LABEL = "com.happy-cli.daemon";
+const PLIST_FILE = `/Library/LaunchDaemons/${PLIST_LABEL}.plist`;
+async function uninstall$1() {
+  try {
+    if (!fs.existsSync(PLIST_FILE)) {
+      types.logger.info("Daemon plist not found. Nothing to uninstall.");
+      return;
+    }
+    try {
+      child_process.execSync(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
+      types.logger.info("Daemon stopped successfully");
+    } catch (error) {
+      types.logger.info("Failed to unload daemon (it might not be running)");
+    }
+    fs.unlinkSync(PLIST_FILE);
+    types.logger.info(`Removed daemon plist from ${PLIST_FILE}`);
+    types.logger.info("Daemon uninstalled successfully");
+  } catch (error) {
+    types.logger.debug("Failed to uninstall daemon:", error);
+    throw error;
+  }
+}
+
+async function uninstall() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon uninstallation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon uninstallation requires sudo privileges. Please run with sudo.");
+  }
+  types.logger.info("Uninstalling Happy CLI daemon for macOS...");
+  await uninstall$1();
+}
+
 (async () => {
   const args = process.argv.slice(2);
   let installationLocation = args.includes("--local") || process.env.HANDY_LOCAL ? "local" : "global";
@@ -1302,39 +1878,40 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
     }
     return;
   } else if (subcommand === "daemon") {
-    if (process.env.HAPPY_DAEMON_MODE) {
-      const { run } = await Promise.resolve().then(function () { return require('./run-q2To6b-c.cjs'); });
-      await run();
+    const daemonSubcommand = args[1];
+    if (daemonSubcommand === "start") {
+      await startDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "stop") {
+      await stopDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "install") {
+      try {
+        await install();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else if (daemonSubcommand === "uninstall") {
+      try {
+        await uninstall();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
     } else {
-      const daemonSubcommand = args[1];
-      if (daemonSubcommand === "install") {
-        const { install } = await Promise.resolve().then(function () { return require('./install-B2r_gX72.cjs'); });
-        try {
-          await install();
-        } catch (error) {
-          console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-          process.exit(1);
-        }
-      } else if (daemonSubcommand === "uninstall") {
-        const { uninstall } = await Promise.resolve().then(function () { return require('./uninstall-C42CoSCI.cjs'); });
-        try {
-          await uninstall();
-        } catch (error) {
-          console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-          process.exit(1);
-        }
-      } else {
-        console.log(`
+      console.log(`
 ${chalk.bold("happy daemon")} - Daemon management
 
 ${chalk.bold("Usage:")}
+  happy daemon start            Start the daemon
+  happy daemon stop             Stop the daemon
   sudo happy daemon install     Install the daemon (requires sudo)
   sudo happy daemon uninstall   Uninstall the daemon (requires sudo)
 
 ${chalk.bold("Note:")} The daemon runs in the background and provides persistent services.
 Currently only supported on macOS.
 `);
-      }
     }
     return;
   } else {
@@ -1370,7 +1947,6 @@ ${chalk.bold("happy")} - Claude Code session sharing
 ${chalk.bold("Usage:")}
   happy [options]
   happy logout     Logs out of your account and removes data directory
-  happy daemon     Manage the background daemon (macOS only)
 
 ${chalk.bold("Options:")}
   -h, --help              Show this help message
@@ -1383,9 +1959,8 @@ ${chalk.bold("Options:")}
   --local < global | local >
       Will use .happy folder in the current directory for storing your private key and debug logs. 
       You will require re-login each time you run this in a new directory.
-
-  --happy-starting-mode <mode>  Start in specified mode (interactive or remote) 
-      Default: interactive
+  --happy-starting-mode <interactive|remote>
+      Set the starting mode for new sessions (default: remote)
 
 ${chalk.bold("Examples:")}
   happy                   Start a session with default settings