@zonease/happy 0.6.38 → 0.6.39

package/dist/index.cjs

@@ -1,48 +1,820 @@
 'use strict';
 
-require('chalk');
-require('./types-DvTsFaqR.cjs');
-require('./index-BbCDDvoB.cjs');
-require('zod');
-require('node:child_process');
-require('axios');
-require('fs');
+var chalk = require('chalk');
+var logger = require('./persistence-JLUn_Nou.cjs');
+var z = require('zod');
+var node_child_process = require('node:child_process');
+require('node:fs/promises');
 require('node:fs');
 require('node:os');
 require('node:path');
-require('node:events');
-require('socket.io-client');
-require('@paralleldrive/cuid2');
 require('node:crypto');
 require('tweetnacl');
-require('node:fs/promises');
-require('node:util');
-require('child_process');
-require('util');
-require('fs/promises');
-require('path');
-require('url');
-require('node:module');
-require('ws');
-require('crypto');
-require('@stablelib/base64');
-require('node:readline');
-require('expo-server-sdk');
-require('./mcpToolSchemas-f-kttjFw.cjs');
-require('ink');
-require('react');
-require('node:url');
-require('ps-list');
-require('cross-spawn');
-require('os');
-require('tmp');
-require('qrcode-terminal');
-require('open');
-require('fastify');
-require('fastify-type-provider-zod');
-require('@modelcontextprotocol/sdk/server/mcp.js');
-require('node:http');
-require('@modelcontextprotocol/sdk/server/streamableHttp.js');
-require('@modelcontextprotocol/sdk/types.js');
-require('http');
+require('fs');
+
+async function spawnAndWaitForDaemon() {
+  const { spawnHappyCLI } = await Promise.resolve().then(function () { return require('./spawnHappyCLI-D_V-AAoP.cjs'); }).then(function (n) { return n.spawnHappyCLI$1; });
+  const { checkIfDaemonRunningAndCleanupStaleState } = await Promise.resolve().then(function () { return require('./controlClient-DZMIsKsT.cjs'); });
+  const child = spawnHappyCLI(["daemon", "start-sync"], {
+    detached: true,
+    stdio: "ignore"
+  });
+  child.unref();
+  for (let i = 0; i < 50; i++) {
+    if (await checkIfDaemonRunningAndCleanupStaleState()) {
+      return true;
+    }
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return false;
+}
+(async () => {
+  const args = process.argv.slice(2);
+  if (!args.includes("--version")) {
+    logger.logger.debug("Starting happy CLI with args: ", process.argv);
+  }
+  const subcommand = args[0];
+  if (!args.includes("--version")) ;
+  if (subcommand === "orchestrator-oneshot") {
+    try {
+      const { runOrchestratorOneShot } = await Promise.resolve().then(function () { return require('./runOneShot-1B6RMYT7.cjs'); });
+      const exitCode = await runOrchestratorOneShot(args.slice(1));
+      process.exit(exitCode);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "doctor") {
+    const { killRunawayHappyProcesses } = await Promise.resolve().then(function () { return require('./doctor-C08m5Z9f.cjs'); });
+    const { runDoctorCommand } = await Promise.resolve().then(function () { return require('./doctor-Cya9YSA0.cjs'); });
+    if (args[1] === "clean") {
+      const result = await killRunawayHappyProcesses();
+      console.log(`Cleaned up ${result.killed} runaway processes`);
+      if (result.errors.length > 0) {
+        console.log("Errors:", result.errors);
+      }
+      process.exit(0);
+    }
+    await runDoctorCommand();
+    return;
+  } else if (subcommand === "auth") {
+    try {
+      const { handleAuthCommand } = await Promise.resolve().then(function () { return require('./auth-Cas9DR3b.cjs'); });
+      await handleAuthCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "connect") {
+    try {
+      const { handleConnectCommand } = await Promise.resolve().then(function () { return require('./connect-CJZ73syK.cjs'); });
+      await handleConnectCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "codex") {
+    const { authAndSetupMachineIfNeeded } = await Promise.resolve().then(function () { return require('./auth-BIleVCw0.cjs'); });
+    const { isDaemonRunningCurrentlyInstalledHappyVersion } = await Promise.resolve().then(function () { return require('./controlClient-DZMIsKsT.cjs'); });
+    const { spawnHappyCLI } = await Promise.resolve().then(function () { return require('./spawnHappyCLI-D_V-AAoP.cjs'); }).then(function (n) { return n.spawnHappyCLI$1; });
+    try {
+      const { runCodex } = await Promise.resolve().then(function () { return require('./runCodex-82UrZLme.cjs'); });
+      let startedBy = void 0;
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--started-by") {
+          startedBy = args[++i];
+        }
+      }
+      const {
+        credentials
+      } = await authAndSetupMachineIfNeeded();
+      logger.logger.debug("Ensuring Happy background service is running & matches our version...");
+      if (!await isDaemonRunningCurrentlyInstalledHappyVersion()) {
+        logger.logger.debug("Starting Happy background service...");
+        const daemonProcess = spawnHappyCLI(["daemon", "start-sync"], {
+          detached: true,
+          stdio: "ignore",
+          env: process.env
+        });
+        daemonProcess.unref();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      await runCodex({ credentials, startedBy });
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "gemini") {
+    const { authAndSetupMachineIfNeeded } = await Promise.resolve().then(function () { return require('./auth-BIleVCw0.cjs'); });
+    const { isDaemonRunningCurrentlyInstalledHappyVersion } = await Promise.resolve().then(function () { return require('./controlClient-DZMIsKsT.cjs'); });
+    const { spawnHappyCLI } = await Promise.resolve().then(function () { return require('./spawnHappyCLI-D_V-AAoP.cjs'); }).then(function (n) { return n.spawnHappyCLI$1; });
+    const geminiSubcommand = args[1];
+    if (geminiSubcommand === "model" && args[2] === "set" && args[3]) {
+      const modelName = args[3];
+      const validModels = ["gemini-2.5-pro", "gemini-2.5-flash", "gemini-2.5-flash-lite"];
+      if (!validModels.includes(modelName)) {
+        console.error(`Invalid model: ${modelName}`);
+        console.error(`Available models: ${validModels.join(", ")}`);
+        process.exit(1);
+      }
+      try {
+        const { existsSync, readFileSync, writeFileSync, mkdirSync } = require("fs");
+        const { join } = require("path");
+        const { homedir } = require("os");
+        const configDir = join(homedir(), ".gemini");
+        const configPath = join(configDir, "config.json");
+        if (!existsSync(configDir)) {
+          mkdirSync(configDir, { recursive: true });
+        }
+        let config = {};
+        if (existsSync(configPath)) {
+          try {
+            config = JSON.parse(readFileSync(configPath, "utf-8"));
+          } catch (error) {
+            config = {};
+          }
+        }
+        config.model = modelName;
+        writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+        console.log(`\u2713 Model set to: ${modelName}`);
+        console.log(`  Config saved to: ${configPath}`);
+        console.log(`  This model will be used in future sessions.`);
+        process.exit(0);
+      } catch (error) {
+        console.error("Failed to save model configuration:", error);
+        process.exit(1);
+      }
+    }
+    if (geminiSubcommand === "model" && args[2] === "get") {
+      try {
+        const { existsSync, readFileSync } = require("fs");
+        const { join } = require("path");
+        const { homedir } = require("os");
+        const configPaths = [
+          join(homedir(), ".gemini", "config.json"),
+          join(homedir(), ".config", "gemini", "config.json")
+        ];
+        let model = null;
+        for (const configPath of configPaths) {
+          if (existsSync(configPath)) {
+            try {
+              const config = JSON.parse(readFileSync(configPath, "utf-8"));
+              model = config.model || config.GEMINI_MODEL || null;
+              if (model) break;
+            } catch (error) {
+            }
+          }
+        }
+        if (model) {
+          console.log(`Current model: ${model}`);
+        } else if (process.env.GEMINI_MODEL) {
+          console.log(`Current model: ${process.env.GEMINI_MODEL} (from GEMINI_MODEL env var)`);
+        } else {
+          console.log("Current model: gemini-2.5-pro (default)");
+        }
+        process.exit(0);
+      } catch (error) {
+        console.error("Failed to read model configuration:", error);
+        process.exit(1);
+      }
+    }
+    if (geminiSubcommand === "project" && args[2] === "set" && args[3]) {
+      const projectId = args[3];
+      try {
+        const { saveGoogleCloudProjectToConfig } = await Promise.resolve().then(function () { return require('./config-Draa-5XC.cjs'); });
+        const { readCredentials: readCredentials2 } = await Promise.resolve().then(function () { return require('./persistence-JLUn_Nou.cjs'); }).then(function (n) { return n.persistence; });
+        const { ApiClient } = await Promise.resolve().then(function () { return require('./api-CwOCQeLH.cjs'); }).then(function (n) { return n.api; });
+        let userEmail = void 0;
+        try {
+          const credentials = await readCredentials2();
+          if (credentials) {
+            const api = await ApiClient.create(credentials);
+            const vendorToken = await api.getVendorToken("gemini");
+            if (vendorToken?.oauth?.id_token) {
+              const parts = vendorToken.oauth.id_token.split(".");
+              if (parts.length === 3) {
+                const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString("utf8"));
+                userEmail = payload.email;
+              }
+            }
+          }
+        } catch {
+        }
+        saveGoogleCloudProjectToConfig(projectId, userEmail);
+        console.log(`\u2713 Google Cloud Project set to: ${projectId}`);
+        if (userEmail) {
+          console.log(`  Linked to account: ${userEmail}`);
+        }
+        console.log(`  This project will be used for Google Workspace accounts.`);
+        process.exit(0);
+      } catch (error) {
+        console.error("Failed to save project configuration:", error);
+        process.exit(1);
+      }
+    }
+    if (geminiSubcommand === "project" && args[2] === "get") {
+      try {
+        const { readGeminiLocalConfig } = await Promise.resolve().then(function () { return require('./config-Draa-5XC.cjs'); });
+        const config = readGeminiLocalConfig();
+        if (config.googleCloudProject) {
+          console.log(`Current Google Cloud Project: ${config.googleCloudProject}`);
+          if (config.googleCloudProjectEmail) {
+            console.log(`  Linked to account: ${config.googleCloudProjectEmail}`);
+          } else {
+            console.log(`  Applies to: all accounts (global)`);
+          }
+        } else if (process.env.GOOGLE_CLOUD_PROJECT) {
+          console.log(`Current Google Cloud Project: ${process.env.GOOGLE_CLOUD_PROJECT} (from env var)`);
+        } else {
+          console.log("No Google Cloud Project configured.");
+          console.log("");
+          console.log('If you see "Authentication required" error, you may need to set a project:');
+          console.log("  happy gemini project set <your-project-id>");
+          console.log("");
+          console.log("This is required for Google Workspace accounts.");
+          console.log("Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca");
+        }
+        process.exit(0);
+      } catch (error) {
+        console.error("Failed to read project configuration:", error);
+        process.exit(1);
+      }
+    }
+    if (geminiSubcommand === "project" && !args[2]) {
+      console.log("Usage: happy gemini project <command>");
+      console.log("");
+      console.log("Commands:");
+      console.log("  set <project-id>   Set Google Cloud Project ID");
+      console.log("  get                Show current Google Cloud Project ID");
+      console.log("");
+      console.log("Google Workspace accounts require a Google Cloud Project.");
+      console.log('If you see "Authentication required" error, set your project ID.');
+      console.log("");
+      console.log("Guide: https://goo.gle/gemini-cli-auth-docs#workspace-gca");
+      process.exit(0);
+    }
+    try {
+      const { runGemini } = await Promise.resolve().then(function () { return require('./runGemini-CXMr4Jwb.cjs'); });
+      let startedBy = void 0;
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--started-by") {
+          startedBy = args[++i];
+        }
+      }
+      const {
+        credentials
+      } = await authAndSetupMachineIfNeeded();
+      logger.logger.debug("Ensuring Happy background service is running & matches our version...");
+      if (!await isDaemonRunningCurrentlyInstalledHappyVersion()) {
+        logger.logger.debug("Starting Happy background service...");
+        const daemonProcess = spawnHappyCLI(["daemon", "start-sync"], {
+          detached: true,
+          stdio: "ignore",
+          env: process.env
+        });
+        daemonProcess.unref();
+        await new Promise((resolve) => setTimeout(resolve, 200));
+      }
+      await runGemini({ credentials, startedBy });
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "update") {
+    try {
+      const { handleUpdateCommand } = await Promise.resolve().then(function () { return require('./update-Dw8pgsAT.cjs'); });
+      await handleUpdateCommand();
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        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 {
+      const { handleAuthCommand } = await Promise.resolve().then(function () { return require('./auth-Cas9DR3b.cjs'); });
+      await handleAuthCommand(["logout"]);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "notify") {
+    try {
+      await handleNotifyCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "session") {
+    try {
+      const { handleSessionCommand } = await Promise.resolve().then(function () { return require('./session-D--F87zL.cjs'); });
+      await handleSessionCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "task") {
+    try {
+      const { handleTaskCommand } = await Promise.resolve().then(function () { return require('./task-CSpaC9HX.cjs'); });
+      await handleTaskCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "release") {
+    try {
+      const { handleReleaseCommand } = await Promise.resolve().then(function () { return require('./release-EhOJeAZe.cjs'); });
+      await handleReleaseCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "github") {
+    try {
+      const { handleGithubCommand } = await Promise.resolve().then(function () { return require('./github-h9GhJJ_C.cjs'); });
+      await handleGithubCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "diagnose") {
+    try {
+      const { handleDiagnoseCommand } = await Promise.resolve().then(function () { return require('./diagnose-B3D1a_v0.cjs'); });
+      await handleDiagnoseCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "evidence") {
+    try {
+      const { handleEvidenceCommand } = await Promise.resolve().then(function () { return require('./evidence-CjWBG5rX.cjs'); });
+      await handleEvidenceCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "mcp") {
+    const mcpSubcommand = args[1];
+    if (mcpSubcommand !== "serve") {
+      console.error(chalk.red("Usage: happy mcp serve"));
+      process.exit(1);
+    }
+    try {
+      const { runMcpServe } = await Promise.resolve().then(function () { return require('./serve-BtdAhkIE.cjs'); });
+      await runMcpServe();
+    } catch (error) {
+      process.stderr.write(`[happy-mcp] fatal: ${error instanceof Error ? error.message : "unknown error"}
+`);
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "ssh") {
+    const credentials = await logger.readCredentials();
+    if (!credentials) {
+      console.error(chalk.red("Error:"), 'Not authenticated. Run "happy auth" first.');
+      process.exit(1);
+    }
+    const { parseSshArgs, runOnDevice, sshDevice, sshPickAndConnect } = await Promise.resolve().then(function () { return require('./ssh-BTOlhhxi.cjs'); });
+    const { target, command, timeoutMs } = parseSshArgs(args.slice(1));
+    try {
+      if (command) {
+        if (!target) {
+          console.error(chalk.red("Error:"), "Which device? Usage: happy ssh <device> -- <command>");
+          process.exit(1);
+        }
+        process.exit(await runOnDevice(credentials, target, command, { timeoutMs }));
+      }
+      if (!target) {
+        process.exit(await sshPickAndConnect(credentials));
+      }
+      process.exit(await sshDevice(credentials, target));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  } else if (subcommand === "device") {
+    const deviceSubcommand = args[1];
+    if (deviceSubcommand === "enroll") {
+      const { enrollDevice } = await Promise.resolve().then(function () { return require('./enroll-BxlbVftP.cjs'); });
+      const { install } = await Promise.resolve().then(function () { return require('./install-C_cp8b2-.cjs'); });
+      const token = args[2];
+      if (!token) {
+        console.error(chalk.red("Error:"), "Missing enrollment token. Usage: happy device enroll <token>");
+        process.exit(1);
+      }
+      try {
+        const result = await enrollDevice(token, { force: args.includes("--force") });
+        if (result.alreadyEnrolled) {
+          console.log("This machine is already linked to a Happy account. Re-run with --force to relink.");
+        } else {
+          console.log("Device enrolled");
+        }
+        await install();
+        console.log("Daemon installed and started");
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+      process.exit(0);
+    }
+    console.log(`
+${chalk.bold("happy device")} - Device enrollment
+
+${chalk.bold("Usage:")}
+  happy device enroll <token>   Link this machine to a Happy account and start the daemon
+`);
+    process.exit(0);
+  } else if (subcommand === "daemon") {
+    const { startDaemon } = await Promise.resolve().then(function () { return require('./run-BDn2aE3Q.cjs'); }).then(function (n) { return n.run; });
+    const { install } = await Promise.resolve().then(function () { return require('./install-C_cp8b2-.cjs'); });
+    const { uninstall } = await Promise.resolve().then(function () { return require('./uninstall-BiKyRAb1.cjs'); });
+    const { runDoctorCommand } = await Promise.resolve().then(function () { return require('./doctor-Cya9YSA0.cjs'); });
+    const { getLatestDaemonLog } = await Promise.resolve().then(function () { return require('./persistence-JLUn_Nou.cjs'); }).then(function (n) { return n.logger$1; });
+    const { listDaemonSessions, stopDaemonSession, stopDaemon } = await Promise.resolve().then(function () { return require('./controlClient-DZMIsKsT.cjs'); });
+    const daemonSubcommand = args[1];
+    if (daemonSubcommand === "list") {
+      try {
+        const sessions = await listDaemonSessions();
+        if (sessions.length === 0) {
+          console.log("No active sessions this daemon is aware of (they might have been started by a previous version of the daemon)");
+        } else {
+          console.log("Active sessions:");
+          console.log(JSON.stringify(sessions, 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 started = await spawnAndWaitForDaemon();
+      console.log(started ? "Daemon started successfully" : "Failed to start daemon");
+      process.exit(started ? 0 : 1);
+    } else if (daemonSubcommand === "start-sync") {
+      await startDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "stop") {
+      await stopDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "restart") {
+      await stopDaemon();
+      const started = await spawnAndWaitForDaemon();
+      console.log(started ? "Daemon restarted successfully" : "Failed to restart daemon");
+      process.exit(started ? 0 : 1);
+    } else if (daemonSubcommand === "status") {
+      await runDoctorCommand("daemon");
+      process.exit(0);
+    } else if (daemonSubcommand === "logs") {
+      const latest = await getLatestDaemonLog();
+      if (!latest) {
+        console.log("No daemon logs found");
+      } else {
+        console.log(latest.path);
+      }
+      process.exit(0);
+    } else if (daemonSubcommand === "enable" || daemonSubcommand === "install") {
+      try {
+        await install();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+      process.exit(0);
+    } else if (daemonSubcommand === "disable" || daemonSubcommand === "uninstall") {
+      try {
+        await uninstall();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+      process.exit(0);
+    } else {
+      console.log(`
+${chalk.bold("happy daemon")} - Daemon management
+
+${chalk.bold("Usage:")}
+  happy daemon start              Start the daemon (detached)
+  happy daemon stop               Stop the daemon (sessions stay alive)
+  happy daemon restart            Restart the daemon
+  happy daemon status             Show daemon status
+  happy daemon list               List active sessions
+  happy daemon enable             Enable auto-start on boot
+  happy daemon disable            Disable auto-start on boot
+
+  If you want to kill all happy related processes run
+  ${chalk.cyan("happy doctor clean")}
+
+${chalk.bold("Note:")} The daemon runs in the background and manages Claude sessions.
+
+${chalk.bold("To clean up runaway processes:")} Use ${chalk.cyan("happy doctor clean")}
+`);
+    }
+    return;
+  } else {
+    if (args.length > 0 && args[0] === "claude") {
+      args.shift();
+    }
+    const options = {};
+    let showHelp = false;
+    let showVersion = false;
+    let chromeOverride = void 0;
+    const unknownArgs = [];
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg === "-h" || arg === "--help") {
+        showHelp = true;
+        unknownArgs.push(arg);
+      } else if (arg === "-v" || arg === "--version") {
+        showVersion = true;
+        unknownArgs.push(arg);
+      } else if (arg === "--happy-starting-mode") {
+        options.startingMode = z.z.enum(["local", "remote"]).parse(args[++i]);
+      } else if (arg === "--yolo") {
+        unknownArgs.push("--dangerously-skip-permissions");
+      } else if (arg === "--started-by") {
+        options.startedBy = args[++i];
+      } else if (arg === "--js-runtime") {
+        const runtime = args[++i];
+        if (runtime !== "node" && runtime !== "bun") {
+          console.error(chalk.red(`Invalid --js-runtime value: ${runtime}. Must be 'node' or 'bun'`));
+          process.exit(1);
+        }
+        options.jsRuntime = runtime;
+      } else if (arg === "--claude-env") {
+        const envArg = args[++i];
+        if (envArg && envArg.includes("=")) {
+          const eqIndex = envArg.indexOf("=");
+          const key = envArg.substring(0, eqIndex);
+          const value = envArg.substring(eqIndex + 1);
+          options.claudeEnvVars = options.claudeEnvVars || {};
+          options.claudeEnvVars[key] = value;
+        } else {
+          console.error(chalk.red(`Invalid --claude-env format: ${envArg}. Expected KEY=VALUE`));
+          process.exit(1);
+        }
+      } else if (arg === "--chrome") {
+        chromeOverride = true;
+      } else if (arg === "--no-chrome") {
+        chromeOverride = false;
+      } else if (arg === "--settings") {
+        const settingsValue = args[++i];
+        console.warn(chalk.yellow(`\u26A0\uFE0F  Warning: --settings is used internally by Happy for session tracking.`));
+        console.warn(chalk.yellow(`   Your settings file "${settingsValue}" will be ignored.`));
+        console.warn(chalk.yellow(`   To configure Claude, edit ~/.claude/settings.json instead.`));
+      } else {
+        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];
+    }
+    const settings = await logger.readSettings();
+    const chromeEnabled = chromeOverride ?? settings.chromeMode ?? false;
+    if (chromeEnabled) {
+      options.claudeArgs = [...options.claudeArgs || [], "--chrome"];
+    }
+    if (showHelp) {
+      console.log(`
+${chalk.bold("happy")} - Claude Code On the Go
+
+${chalk.bold("Usage:")}
+  happy [options]         Start Claude with mobile control
+  happy auth              Manage authentication
+  happy codex             Start Codex mode
+  happy gemini            Start Gemini mode (ACP)
+  happy connect           Connect AI vendor API keys
+  happy session           Read Happy sessions
+  happy task              Generate task handoff briefs
+  happy release           Verify before publishing
+  happy github            GitHub takeover helpers
+  happy diagnose          Diagnosis evidence helpers
+  happy evidence          Record screenshots/log evidence
+  happy notify            Send push notification
+  happy daemon            Manage background service
+  happy daemon enable     Auto-start daemon on boot
+  happy doctor            System diagnostics & troubleshooting
+  happy update            Upgrade happy to the latest version
+
+${chalk.bold("Examples:")}
+  happy                    Start session
+  happy --yolo             Start with bypassing permissions
+                            happy sugar for --dangerously-skip-permissions
+  happy --chrome           Enable Chrome browser access for this session
+  happy --no-chrome        Disable Chrome even if default is on
+  happy --js-runtime bun   Use bun instead of node to spawn Claude Code
+  happy --claude-env ANTHROPIC_BASE_URL=http://127.0.0.1:3456
+                           Use a custom API endpoint (e.g., claude-code-router)
+  happy auth login --force Authenticate
+  happy task brief --recent --project .
+                           Generate a continuation brief
+  happy release guard --package happy-cli
+                           Run checks before publishing
+  happy doctor             Run diagnostics
+
+${chalk.bold("Happy AI supports ALL Claude options!")}
+  Use any claude flag with happy as you would with claude. Our favorite:
+
+  happy --resume
+
+${chalk.gray("\u2500".repeat(60))}
+${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
+`);
+      try {
+        const { claudeCliPath } = await Promise.resolve().then(function () { return require('./claudeLocal-WkgLbl1a.cjs'); }).then(function (n) { return n.claudeLocal$1; });
+        const claudeHelp = node_child_process.execFileSync(claudeCliPath, ["--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) {
+      const versions = [
+        { name: "Happy AI", version: logger.packageJson.version }
+      ];
+      const checks = [
+        { name: "Claude", cmd: "claude", args: ["--version"] },
+        { name: "Codex", cmd: "codex", args: ["--version"] },
+        { name: "Gemini", cmd: "gemini", args: ["--version"] }
+      ];
+      for (const { name, cmd, args: vArgs } of checks) {
+        try {
+          const ver = node_child_process.execFileSync(cmd, vArgs, { encoding: "utf-8", timeout: 5e3 }).trim();
+          versions.push({ name, version: ver });
+        } catch {
+        }
+      }
+      const maxName = Math.max(...versions.map((v) => v.name.length));
+      for (const { name, version } of versions) {
+        console.log(`${chalk.bold(name.padEnd(maxName))}  ${chalk.cyan(version)}`);
+      }
+      process.exit(0);
+    }
+    const { authAndSetupMachineIfNeeded } = await Promise.resolve().then(function () { return require('./auth-BIleVCw0.cjs'); });
+    const { isDaemonRunningCurrentlyInstalledHappyVersion } = await Promise.resolve().then(function () { return require('./controlClient-DZMIsKsT.cjs'); });
+    const { spawnHappyCLI } = await Promise.resolve().then(function () { return require('./spawnHappyCLI-D_V-AAoP.cjs'); }).then(function (n) { return n.spawnHappyCLI$1; });
+    const { runClaude } = await Promise.resolve().then(function () { return require('./runClaude-uaKxPZPm.cjs'); });
+    const {
+      credentials
+    } = await authAndSetupMachineIfNeeded();
+    logger.logger.debug("Ensuring Happy background service is running & matches our version...");
+    if (!await isDaemonRunningCurrentlyInstalledHappyVersion()) {
+      logger.logger.debug("Starting Happy background service...");
+      const daemonProcess = spawnHappyCLI(["daemon", "start-sync"], {
+        detached: true,
+        stdio: "ignore",
+        env: process.env
+      });
+      daemonProcess.unref();
+      await new Promise((resolve) => setTimeout(resolve, 200));
+    }
+    try {
+      await runClaude(credentials, options);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (logger.isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  }
+})();
+async function handleNotifyCommand(args) {
+  let message = "";
+  let title = "";
+  let showHelp = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "-p" && i + 1 < args.length) {
+      message = args[++i];
+    } else if (arg === "-t" && i + 1 < args.length) {
+      title = args[++i];
+    } else if (arg === "-h" || arg === "--help") {
+      showHelp = true;
+    } else {
+      console.error(chalk.red(`Unknown argument for notify command: ${arg}`));
+      process.exit(1);
+    }
+  }
+  if (showHelp) {
+    console.log(`
+${chalk.bold("happy notify")} - Send notification
+
+${chalk.bold("Usage:")}
+  happy notify -p <message> [-t <title>]    Send notification with custom message and optional title
+  happy notify -h, --help                   Show this help
+
+${chalk.bold("Options:")}
+  -p <message>    Notification message (required)
+  -t <title>      Notification title (optional, defaults to "Happy AI")
 
+${chalk.bold("Examples:")}
+  happy notify -p "Deployment complete!"
+  happy notify -p "System update complete" -t "Server Status"
+  happy notify -t "Alert" -p "Database connection restored"
+`);
+    return;
+  }
+  if (!message) {
+    console.error(chalk.red('Error: Message is required. Use -p "your message" to specify the notification text.'));
+    console.log(chalk.gray('Run "happy notify --help" for usage information.'));
+    process.exit(1);
+  }
+  let credentials = await logger.readCredentials();
+  if (!credentials) {
+    console.error(chalk.red('Error: Not authenticated. Please run "happy auth login" first.'));
+    process.exit(1);
+  }
+  console.log(chalk.blue("\u{1F4F1} Sending push notification..."));
+  try {
+    const { ApiClient } = await Promise.resolve().then(function () { return require('./api-CwOCQeLH.cjs'); }).then(function (n) { return n.api; });
+    const api = await ApiClient.create(credentials);
+    const notificationTitle = title || "Happy AI";
+    api.push().sendToAllDevices(
+      notificationTitle,
+      message,
+      {
+        source: "cli",
+        timestamp: Date.now()
+      }
+    );
+    console.log(chalk.green("\u2713 Push notification sent successfully!"));
+    console.log(chalk.gray(`  Title: ${notificationTitle}`));
+    console.log(chalk.gray(`  Message: ${message}`));
+    console.log(chalk.gray("  Check your mobile device for the notification."));
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  } catch (error) {
+    console.error(chalk.red("\u2717 Failed to send push notification"));
+    throw error;
+  }
+}