@zonease/happy 0.6.38 → 0.6.40

package/dist/index.mjs

@@ -1,45 +1,818 @@
-import 'chalk';
-import './types-BWpRU1VN.mjs';
-import './index-vvZXdswy.mjs';
-import 'zod';
-import 'node:child_process';
-import 'axios';
-import 'fs';
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
+import { l as logger, i as isDebug, r as readCredentials, a as readSettings, p as packageJson } from './persistence-DKfF81pd.mjs';
+import { z } from 'zod';
+import { execFileSync } from 'node:child_process';
+import 'node:fs/promises';
 import 'node:fs';
 import 'node:os';
 import 'node:path';
-import 'node:events';
-import 'socket.io-client';
-import '@paralleldrive/cuid2';
 import 'node:crypto';
 import 'tweetnacl';
-import 'node:fs/promises';
-import 'node:util';
-import 'child_process';
-import 'util';
-import 'fs/promises';
-import 'path';
-import 'url';
-import 'node:module';
-import 'ws';
-import 'crypto';
-import '@stablelib/base64';
-import 'node:readline';
-import 'expo-server-sdk';
-import './mcpToolSchemas-CdPXJQmb.mjs';
-import 'ink';
-import 'react';
-import 'node:url';
-import 'ps-list';
-import 'cross-spawn';
-import 'os';
-import 'tmp';
-import 'qrcode-terminal';
-import 'open';
-import 'fastify';
-import 'fastify-type-provider-zod';
-import '@modelcontextprotocol/sdk/server/mcp.js';
-import 'node:http';
-import '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import '@modelcontextprotocol/sdk/types.js';
-import 'http';
+import 'fs';
+
+async function spawnAndWaitForDaemon() {
+  const { spawnHappyCLI } = await import('./spawnHappyCLI-yBIP_Oqi.mjs').then(function (n) { return n.a; });
+  const { checkIfDaemonRunningAndCleanupStaleState } = await import('./controlClient-DB5tDU7V.mjs');
+  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.debug("Starting happy CLI with args: ", process.argv);
+  }
+  const subcommand = args[0];
+  if (!args.includes("--version")) ;
+  if (subcommand === "orchestrator-oneshot") {
+    try {
+      const { runOrchestratorOneShot } = await import('./runOneShot-CdCWiiLr.mjs');
+      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 (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "doctor") {
+    const { killRunawayHappyProcesses } = await import('./doctor-ON7pN5G5.mjs');
+    const { runDoctorCommand } = await import('./doctor-CU4JLGQ1.mjs');
+    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 import('./auth-DO9GexAR.mjs');
+      await handleAuthCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "connect") {
+    try {
+      const { handleConnectCommand } = await import('./connect-BXLUKJ5P.mjs');
+      await handleConnectCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "codex") {
+    const { authAndSetupMachineIfNeeded } = await import('./auth-DxJ3VvrX.mjs');
+    const { isDaemonRunningCurrentlyInstalledHappyVersion } = await import('./controlClient-DB5tDU7V.mjs');
+    const { spawnHappyCLI } = await import('./spawnHappyCLI-yBIP_Oqi.mjs').then(function (n) { return n.a; });
+    try {
+      const { runCodex } = await import('./runCodex-ClwEgJ7M.mjs');
+      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.debug("Ensuring Happy background service is running & matches our version...");
+      if (!await isDaemonRunningCurrentlyInstalledHappyVersion()) {
+        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 (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "gemini") {
+    const { authAndSetupMachineIfNeeded } = await import('./auth-DxJ3VvrX.mjs');
+    const { isDaemonRunningCurrentlyInstalledHappyVersion } = await import('./controlClient-DB5tDU7V.mjs');
+    const { spawnHappyCLI } = await import('./spawnHappyCLI-yBIP_Oqi.mjs').then(function (n) { return n.a; });
+    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 import('./config-DZk-mJ0K.mjs');
+        const { readCredentials: readCredentials2 } = await import('./persistence-DKfF81pd.mjs').then(function (n) { return n.F; });
+        const { ApiClient } = await import('./api-D6WL40-U.mjs').then(function (n) { return n.m; });
+        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 import('./config-DZk-mJ0K.mjs');
+        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 import('./runGemini-BPWxVr60.mjs');
+      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.debug("Ensuring Happy background service is running & matches our version...");
+      if (!await isDaemonRunningCurrentlyInstalledHappyVersion()) {
+        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 (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "update") {
+    try {
+      const { handleUpdateCommand } = await import('./update-CnnoX2cV.mjs');
+      await handleUpdateCommand();
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (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 import('./auth-DO9GexAR.mjs');
+      await handleAuthCommand(["logout"]);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (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 (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "session") {
+    try {
+      const { handleSessionCommand } = await import('./session-BXboDn2V.mjs');
+      await handleSessionCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "task") {
+    try {
+      const { handleTaskCommand } = await import('./task-wNX1N2i4.mjs');
+      await handleTaskCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "release") {
+    try {
+      const { handleReleaseCommand } = await import('./release-BMEzNONE.mjs');
+      await handleReleaseCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "github") {
+    try {
+      const { handleGithubCommand } = await import('./github-DKcyF1zp.mjs');
+      await handleGithubCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "diagnose") {
+    try {
+      const { handleDiagnoseCommand } = await import('./diagnose-CuRKXxt1.mjs');
+      await handleDiagnoseCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (isDebug()) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "evidence") {
+    try {
+      const { handleEvidenceCommand } = await import('./evidence-DTYRAaOZ.mjs');
+      await handleEvidenceCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (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 import('./serve-B48JttQ3.mjs');
+      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 readCredentials();
+    if (!credentials) {
+      console.error(chalk.red("Error:"), 'Not authenticated. Run "happy auth" first.');
+      process.exit(1);
+    }
+    const { parseSshArgs, runOnDevice, sshDevice, sshPickAndConnect } = await import('./ssh-q5uZhqBf.mjs');
+    const { target, command, timeoutMs, stream } = 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, stream }));
+      }
+      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 import('./enroll-B55BQR56.mjs');
+      const { install } = await import('./install-B1e6rdy7.mjs');
+      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 import('./run-BVZsMNwN.mjs').then(function (n) { return n.r; });
+    const { install } = await import('./install-B1e6rdy7.mjs');
+    const { uninstall } = await import('./uninstall-Dxf6_4mQ.mjs');
+    const { runDoctorCommand } = await import('./doctor-CU4JLGQ1.mjs');
+    const { getLatestDaemonLog } = await import('./persistence-DKfF81pd.mjs').then(function (n) { return n.E; });
+    const { listDaemonSessions, stopDaemonSession, stopDaemon } = await import('./controlClient-DB5tDU7V.mjs');
+    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.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 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 import('./claudeLocal-CWNGpJ0-.mjs').then(function (n) { return n.d; });
+        const claudeHelp = 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: 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 = 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 import('./auth-DxJ3VvrX.mjs');
+    const { isDaemonRunningCurrentlyInstalledHappyVersion } = await import('./controlClient-DB5tDU7V.mjs');
+    const { spawnHappyCLI } = await import('./spawnHappyCLI-yBIP_Oqi.mjs').then(function (n) { return n.a; });
+    const { runClaude } = await import('./runClaude-6Gi0sYQy.mjs');
+    const {
+      credentials
+    } = await authAndSetupMachineIfNeeded();
+    logger.debug("Ensuring Happy background service is running & matches our version...");
+    if (!await isDaemonRunningCurrentlyInstalledHappyVersion()) {
+      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 (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 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 import('./api-D6WL40-U.mjs').then(function (n) { return n.m; });
+    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;
+  }
+}