very-happy-cli 0.2.159 → 0.2.160

package/dist/main-BwNIAI1A.mjs

@@ -0,0 +1,939 @@
+import{createRequire as _pkgrollCR}from"node:module";const require=_pkgrollCR(import.meta.url);import chalk from 'chalk';
+import { l as logger, g as getLatestDaemonLog } from './logger-6HYUEXNk.mjs';
+import { readDaemonState, readSettings, readCredentialsForConfiguredRelay } from './persistence-HGW_ZVs9.mjs';
+import { a as authAndSetupMachineIfNeeded } from './auth-Cwutmdsa.mjs';
+import { p as packageJson } from './package-BhaKlnxz.mjs';
+import { z } from 'zod';
+import { l as listDaemonSessions, s as stopDaemonSession, c as checkIfDaemonRunningAndCleanupStaleState, a as stopDaemon } from './controlClient-BGbDcgWS.mjs';
+import { p as parsePiRunnerArgs, S as SYSTEMD_RESTART_HINT, a as piAdapterMissingHint } from './piRunnerArgs-BuX1UFWy.mjs';
+import { s as spawnHappyCLI } from './spawnHappyCLI-B2H5s4B_.mjs';
+import { execFileSync } from 'node:child_process';
+import { e as ensureDaemonRunning, a as extractNoSandboxFlag } from './ensureDaemonRunning-Dqa2pOjY.mjs';
+import { p as planClaudeStartup } from './startupPlan-DFMyNgAs.mjs';
+import { i as isStandaloneVersionRequest } from './index-DVkMGPyS.mjs';
+import { c as configuration } from './configuration-RfeNjFmd.mjs';
+import { d as daemonEndpointsMatch } from './doctorReadiness-C208SMN9.mjs';
+import 'node:util';
+import 'node:fs';
+import 'node:path';
+import 'node:fs/promises';
+import './authRelay-DSAvg1uv.mjs';
+import 'node:crypto';
+import 'tweetnacl';
+import 'node:os';
+import 'axios';
+import './time-D0XyHOid.mjs';
+import './browser-jh2P0UVZ.mjs';
+import 'open';
+import './sessionModeFile-DMl3dw3r.mjs';
+import 'cross-spawn';
+import './projectPath-BTBIMB57.mjs';
+import 'path';
+import 'url';
+import 'node:module';
+import './detectCLI-CSGMlV51.mjs';
+import 'child_process';
+import 'os';
+import 'fs';
+
+const DAEMON_STOP_HELP = "Stop the daemon (tmux sessions stay alive; direct-shell terminals end)";
+const CLAUDE_OPTIONS_HELP = `Very Happy forwards most Claude options.
+  Use Claude flags with very-happy as you would with claude. The --settings flag
+  is reserved for Very Happy's session hooks and is ignored with a warning.`;
+
+async function main() {
+  const args = process.argv.slice(2);
+  if (isStandaloneVersionRequest(args)) {
+    console.log(`very-happy version: ${packageJson.version}`);
+    return;
+  }
+  if (!args.includes("--version")) {
+    logger.debug("Starting happy CLI with args: ", process.argv);
+  }
+  const subcommand = args[0];
+  if (!args.includes("--version")) ;
+  if (subcommand === "doctor") {
+    if (args[1] === "clean") {
+      if (args.slice(2).some((a) => a === "--help" || a === "-h")) {
+        console.log(`
+${chalk.bold("very-happy doctor clean")} - Kill all Very Happy processes (daemon + sessions)
+
+${chalk.bold("Usage:")}
+  very-happy doctor clean
+
+${chalk.bold("Warning:")} This is destructive \u2014 it terminates the daemon and every running session.
+Conversation history is preserved on the server, but in-flight tool calls are interrupted.
+`);
+        process.exit(0);
+      }
+      const result = await (await import('./doctor-BPkYWSuq.mjs')).killRunawayHappyProcesses();
+      console.log(`Cleaned up ${result.killed} runaway processes`);
+      if (result.errors.length > 0) {
+        console.log("Errors:", result.errors);
+      }
+      process.exit(0);
+    }
+    await (await import('./doctor-DOvByjbk.mjs').then(function (n) { return n.d; })).runDoctorCommand();
+    return;
+  } else if (subcommand === "auth") {
+    try {
+      await (await import('./auth-PYHZQNPp.mjs')).handleAuthCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "connect") {
+    try {
+      await (await import('./connect-BpOdzNbE.mjs')).handleConnectCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "sandbox") {
+    try {
+      await (await import('./sandbox-DTe6d54R.mjs')).handleSandboxCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "server") {
+    try {
+      await (await import('./server-DcVBv04l.mjs')).handleServerCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "bye") {
+    console.log("Bye!");
+    process.exit(0);
+  } else if (subcommand === "install-pi-tools") {
+    try {
+      const { handleInstallPiTools } = await import('./installPiTools-B_CdM5_2.mjs');
+      await handleInstallPiTools(args.slice(1));
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : "Pi tools installation failed");
+      process.exitCode = 1;
+    }
+    return;
+  } else if (subcommand === "install-terminal-hooks") {
+    try {
+      const { installTerminalHooks, parseTerminalHooksArgs, TERMINAL_HOOKS_HELP } = await import('./installTerminalHooks-By7gBMEF.mjs');
+      const command = parseTerminalHooksArgs(args.slice(1));
+      if (command.action === "help") {
+        console.log(TERMINAL_HOOKS_HELP);
+        return;
+      }
+      await installTerminalHooks({ remove: command.action === "remove" });
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+  } else if (subcommand === "agent-home") {
+    try {
+      const { parseAgentHomeArgs, runAgentHomeCommand } = await import('./agentHome-Dj1C43aJ.mjs');
+      await runAgentHomeCommand(parseAgentHomeArgs(args.slice(1)));
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  } else if (subcommand === "spawn") {
+    try {
+      const { handleSpawnCommand } = await import('./spawn-B7yro0b2.mjs');
+      await handleSpawnCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "sessions") {
+    try {
+      const { handleSessionsCommand } = await import('./sessions-BEG_HTSi.mjs');
+      await handleSessionsCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "send") {
+    try {
+      const { handleSendCommand } = await import('./send-CBXJKc6O.mjs');
+      await handleSendCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "resume") {
+    try {
+      await (await import('./handleResumeCommand-BvXYf5El.mjs')).handleResumeCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "codex") {
+    try {
+      await (await import('./codexCommand-Cc9gcbdX.mjs')).handleCodexCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "gemini") {
+    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-CTx_jb-C.mjs');
+        const { readCredentialsForConfiguredRelay: readCredentialsForConfiguredRelay2 } = await import('./persistence-HGW_ZVs9.mjs');
+        const { ApiClient } = await import('./api-CLMUr-SX.mjs').then(function (n) { return n.b; });
+        let userEmail = void 0;
+        try {
+          const credentials = await readCredentialsForConfiguredRelay2();
+          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-CTx_jb-C.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("  very-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: very-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-BGeTz57m.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();
+      await ensureDaemonRunning();
+      await runGemini({ credentials, startedBy });
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "pi") {
+    if (args[1] === "--terminal") {
+      try {
+        const { runPiTerminal } = await import('./piTerminal-C8a1OrNQ.mjs');
+        process.exitCode = await runPiTerminal(args.slice(2));
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exitCode = 1;
+      }
+      return;
+    }
+    let hintPrinted = false;
+    const printHint = (detail) => {
+      const hint = piAdapterMissingHint(detail);
+      if (hint && !hintPrinted) {
+        hintPrinted = true;
+        console.error(chalk.gray(hint));
+      }
+    };
+    try {
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-DMZqWwsP.mjs');
+      const parsed = parsePiRunnerArgs(args.slice(1));
+      const resolved = resolveAcpAgentConfig(["pi", ...parsed.passthrough]);
+      const { credentials } = await authAndSetupMachineIfNeeded();
+      await ensureDaemonRunning();
+      await runAcp({
+        credentials,
+        startedBy: parsed.startedBy,
+        verbose: parsed.verbose,
+        permissionMode: parsed.permissionMode,
+        model: parsed.model,
+        agentName: resolved.agentName,
+        command: resolved.command,
+        args: resolved.args,
+        onBackendError: printHint
+      });
+      if (hintPrinted) process.exit(1);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      printHint(error instanceof Error ? error.message : void 0);
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "acp") {
+    try {
+      const { runAcp, resolveAcpAgentConfig } = await import('./index-DMZqWwsP.mjs');
+      let startedBy = void 0;
+      let verbose = false;
+      const acpArgs = [];
+      let customCommandMode = false;
+      for (let i = 1; i < args.length; i++) {
+        if (!customCommandMode && args[i] === "--started-by") {
+          startedBy = args[++i];
+          continue;
+        }
+        if (!customCommandMode && args[i] === "--verbose") {
+          verbose = true;
+          continue;
+        }
+        if (args[i] === "--") {
+          customCommandMode = true;
+        }
+        acpArgs.push(args[i]);
+      }
+      const resolved = resolveAcpAgentConfig(acpArgs);
+      const { credentials } = await authAndSetupMachineIfNeeded();
+      await ensureDaemonRunning();
+      await runAcp({
+        credentials,
+        startedBy,
+        verbose,
+        agentName: resolved.agentName,
+        command: resolved.command,
+        args: resolved.args
+      });
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "openclaw") {
+    try {
+      const { runOpenClaw } = await import('./runOpenClaw-CogSedIc.mjs');
+      let startedBy = void 0;
+      let verbose = false;
+      let gatewayUrl;
+      let gatewayToken;
+      let gatewayPassword;
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--started-by") {
+          startedBy = args[++i];
+        } else if (args[i] === "--verbose") {
+          verbose = true;
+        } else if (args[i] === "--gateway-url") {
+          gatewayUrl = args[++i];
+        } else if (args[i] === "--gateway-token") {
+          gatewayToken = args[++i];
+        } else if (args[i] === "--gateway-password") {
+          gatewayPassword = args[++i];
+        }
+      }
+      const { credentials } = await authAndSetupMachineIfNeeded();
+      await ensureDaemonRunning();
+      await runOpenClaw({
+        credentials,
+        startedBy,
+        verbose,
+        gatewayUrl,
+        gatewayToken,
+        gatewayPassword
+      });
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "logout") {
+    console.log(chalk.yellow('Note: "very-happy logout" is deprecated. Use "very-happy auth logout" instead.\n'));
+    try {
+      await (await import('./auth-PYHZQNPp.mjs')).handleAuthCommand(["logout"]);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "todo") {
+    try {
+      const { handleTodoCommand } = await import('./todo-CZ6cFrrn.mjs');
+      await handleTodoCommand(args.slice(1));
+    } catch (error) {
+      console.error(JSON.stringify({ error: error instanceof Error ? error.message : "Todo command failed" }));
+      process.exitCode = 1;
+    }
+    return;
+  } else if (subcommand === "teams") {
+    try {
+      const { handleTeamsCommand } = await import('./teams-C32F1hqd.mjs');
+      await handleTeamsCommand(args.slice(1));
+    } catch (error) {
+      console.error(error instanceof Error ? error.message : "Teams command failed");
+      process.exitCode = 1;
+    }
+    return;
+  } else if (subcommand === "auto") {
+    try {
+      const { handleAutoCommand } = await import('./auto-BXu14yP_.mjs');
+      await handleAutoCommand(args.slice(1));
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Automation command failed");
+      if (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exitCode = 1;
+    }
+    return;
+  } else if (subcommand === "mcp" && (args.length === 1 || args.length === 2 && args[1] === "--terminal-tools")) {
+    try {
+      const { handleMcpCommand } = await import('./mcp-B1A4I3TK.mjs');
+      await handleMcpCommand(args[1] === "--terminal-tools");
+    } catch (error) {
+      process.stderr.write(`[very-happy mcp] Fatal: ${error instanceof Error ? error.message : String(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 (process.env.DEBUG) {
+        console.error(error);
+      }
+      process.exit(1);
+    }
+    return;
+  } else if (subcommand === "daemon") {
+    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));
+          const busy = sessions.filter((s) => s.turnActive === true);
+          console.log(busy.length === 0 ? "No turn in flight on this machine (wrappers older than 0.2.139 do not report turns)." : `${busy.length} session(s) with a turn in flight: ${busy.map((s) => s.happySessionId).join(", ")}`);
+          const background = sessions.filter((s) => (s.backgroundTasks?.count ?? 0) > 0);
+          console.log(background.length === 0 ? "No background tasks in flight (wrappers older than 0.2.157 do not report them)." : `${background.length} session(s) with background tasks in flight: ${background.map((s) => `${s.happySessionId} (${s.backgroundTasks?.count})`).join(", ")}`);
+        }
+      } 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 currentState = await readDaemonState();
+      const running = await checkIfDaemonRunningAndCleanupStaleState();
+      const currentDaemonMatches = currentState && currentState.startedWithCliVersion === configuration.currentCliVersion && daemonEndpointsMatch(
+        currentState.serverUrl,
+        currentState.webappUrl,
+        configuration.serverUrl,
+        configuration.webappUrl
+      );
+      if (running && !currentDaemonMatches) {
+        if (currentState?.supervisor === "systemd") {
+          console.error(`The running daemon is supervised by systemd; hand over through the unit instead:
+  ${SYSTEMD_RESTART_HINT}`);
+          process.exit(1);
+        }
+        console.log("Configured relay or CLI version changed; restarting the existing daemon");
+        await stopDaemon();
+      }
+      const { HAPPY_DAEMON_SUPERVISOR: _supervisor, INVOCATION_ID: _invocation, ...detachedEnv } = process.env;
+      const child = spawnHappyCLI(["daemon", "start-sync"], {
+        detached: true,
+        stdio: "ignore",
+        env: detachedEnv
+      });
+      child.unref();
+      let started = false;
+      for (let i = 0; i < 50; i++) {
+        if (await checkIfDaemonRunningAndCleanupStaleState()) {
+          started = true;
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+      }
+      if (started) {
+        console.log("Daemon started successfully");
+      } else {
+        console.error("Failed to start daemon");
+        process.exit(1);
+      }
+      process.exit(0);
+    } else if (daemonSubcommand === "start-sync") {
+      await (await import('./run-D3ifupU3.mjs')).startDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "stop") {
+      await stopDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "status") {
+      await (await import('./doctor-DOvByjbk.mjs').then(function (n) { return n.d; })).runDoctorDaemon();
+      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 === "install") {
+      try {
+        await (await import('./install-CFY3tYtJ.mjs')).install();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else if (daemonSubcommand === "uninstall") {
+      try {
+        await (await import('./uninstall-BkLzaJ6I.mjs')).uninstall();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else {
+      console.log(`
+${chalk.bold("very-happy daemon")} - Daemon management
+
+${chalk.bold("Usage:")}
+  very-happy daemon start              Start the daemon (detached)
+  very-happy daemon stop               ${DAEMON_STOP_HELP}
+  very-happy daemon status             Show daemon status
+  very-happy daemon list               List active sessions
+
+  If you want to kill all happy related processes run 
+  ${chalk.cyan("very-happy doctor clean")}
+
+${chalk.bold("Note:")} The daemon runs in the background and manages agent sessions and Web terminals.
+
+${chalk.bold("To clean up runaway processes:")} Use ${chalk.cyan("very-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 = [];
+    const parsedSandboxFlag = extractNoSandboxFlag(args);
+    options.noSandbox = parsedSandboxFlag.noSandbox;
+    args.length = 0;
+    args.push(...parsedSandboxFlag.args);
+    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 === "--model") {
+        options.model = args[++i];
+      } 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("very-happy")} - Open agent workspace for Web and terminal
+
+${chalk.bold("Usage:")}
+  very-happy [options]         Start the native Claude TUI with browser control
+                            (requires the external claude command)
+  very-happy auth              Manage authentication
+  very-happy spawn             Spawn a remote session via the local daemon and
+                            print its web URL (for automation; see spawn --help)
+  very-happy send              Send a message into an existing session
+                            (for automation; see send --help)
+  very-happy sessions          List, read, stop, archive, approve or deny
+                            sessions and their permission requests (for
+                            automation; see sessions --help)
+  very-happy codex             Start Codex mode
+  very-happy gemini            Start Gemini mode (ACP)
+  very-happy pi                Start pi mode (ACP via the pi-acp adapter)
+  very-happy pi --terminal     Run native pi with title, clipboard and preview tools
+                            inside a Very Happy terminal
+  very-happy install-pi-tools  Install tools for directly launched pi sessions
+                            (add --remove to uninstall)
+  very-happy acp               Start a generic ACP-compatible agent
+  very-happy openclaw          Connect through a configured OpenClaw gateway
+  very-happy install-terminal-hooks
+                            Install optional Claude terminal mirror hooks
+                            (add --remove to uninstall them)
+  very-happy agent-home        Show or pin where Claude Code / Codex keep their
+                            conversations on this machine (agent-home --help)
+  very-happy connect           Connect AI vendor API keys
+  very-happy todo              Built-in Todos and official agent skill (todo --help)
+  very-happy auto              Scheduled / triggered automations: spawn, sticky
+                            sessions or scripts with tracked runs (auto --help)
+  very-happy sandbox           Configure and manage OS-level sandboxing
+  very-happy notify            Send push notification
+  very-happy mcp               Stdio MCP server exposing copy_to_clipboard for a
+                            plain claude CLI (register once with:
+                            claude mcp add --scope user very-happy-clipboard -- very-happy mcp)
+  very-happy daemon            Manage background service that allows
+                            to spawn new sessions away from your computer
+  very-happy doctor            System diagnostics & troubleshooting
+
+${chalk.bold("Examples:")}
+  very-happy                    Start the native Claude TUI (external claude required)
+  very-happy --yolo             Start with bypassing permissions
+                            shorthand for --dangerously-skip-permissions
+  very-happy --chrome           Enable Chrome browser access for this session
+  very-happy --no-chrome        Disable Chrome even if default is on
+  very-happy --no-sandbox       Disable the Very Happy sandbox for this session
+  very-happy --js-runtime bun   Use bun instead of node to spawn Claude Code
+  very-happy --claude-env ANTHROPIC_BASE_URL=http://127.0.0.1:3456
+                           Use a custom API endpoint (e.g., claude-code-router)
+  very-happy pi                 Start pi (needs pi-acp on PATH)
+  very-happy acp gemini         Start Gemini via generic ACP runner
+  very-happy acp opencode   Start OpenCode through its built-in ACP adapter
+  very-happy acp -- your-agent --acp
+                           Start a custom ACP command that accepts --acp
+  very-happy acp opencode --verbose
+                           Print raw ACP backend/envelope events
+  very-happy install-terminal-hooks
+                           Mirror hand-started Claude inside Very Happy terminals
+  very-happy auth login --force Authenticate
+  very-happy doctor             Run diagnostics
+
+${chalk.bold(CLAUDE_OPTIONS_HELP)}
+  For example:
+
+  very-happy --resume
+
+${chalk.gray("\u2500".repeat(60))}
+${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
+`);
+      try {
+        const { claudeCliPath } = await import('./claudeCliPath-BqkaH2oR.mjs');
+        const claudeHelp = execFileSync(claudeCliPath, ["--help"], { encoding: "utf8", windowsHide: true });
+        console.log(claudeHelp);
+      } catch (e) {
+        console.log(chalk.yellow("Could not retrieve claude help. Make sure claude is installed."));
+      }
+      process.exit(0);
+    }
+    if (showVersion) {
+      console.log(`very-happy version: ${packageJson.version}`);
+    }
+    const {
+      credentials
+    } = await authAndSetupMachineIfNeeded();
+    if (planClaudeStartup({ startedBy: options.startedBy, reconnect: false }).ensureDaemonRunning) {
+      await ensureDaemonRunning();
+    }
+    try {
+      const { runClaude } = await import('./runClaude-Ba01qT-u.mjs');
+      await runClaude(credentials, options);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+      if (process.env.DEBUG) {
+        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("very-happy notify")} - Send notification
+
+${chalk.bold("Usage:")}
+  very-happy notify -p <message> [-t <title>]    Send notification with custom message and optional title
+  very-happy notify -h, --help                   Show this help
+
+${chalk.bold("Options:")}
+  -p <message>    Notification message (required)
+  -t <title>      Notification title (optional, defaults to "Happy")
+
+${chalk.bold("Examples:")}
+  very-happy notify -p "Deployment complete!"
+  very-happy notify -p "System update complete" -t "Server Status"
+  very-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 "very-happy notify --help" for usage information.'));
+    process.exit(1);
+  }
+  let credentials = await readCredentialsForConfiguredRelay();
+  if (!credentials) {
+    console.error(chalk.red('Error: Not authenticated. Please run "very-happy auth login" first.'));
+    process.exit(1);
+  }
+  console.log(chalk.blue("\u{1F4F1} Sending push notification..."));
+  try {
+    const { ApiClient } = await import('./api-CLMUr-SX.mjs').then(function (n) { return n.b; });
+    const api = await ApiClient.create(credentials);
+    const notificationTitle = title || "Happy";
+    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;
+  }
+}
+
+export { main };