happy-coder 0.9.0 → 0.10.0-0

package/dist/index.mjs

@@ -1,11 +1,10 @@
 import chalk from 'chalk';
 import os$1, { homedir } from 'node:os';
 import { randomUUID, randomBytes } from 'node:crypto';
-import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, r as readDaemonState, c as configuration, f as clearDaemonState, p as packageJson, g as readSettings, h as readCredentials, i as encodeBase64, u as updateSettings, j as encodeBase64Url, k as decodeBase64, w as writeCredentials, m as acquireDaemonLock, n as writeDaemonState, A as ApiClient, o as releaseDaemonLock, q as clearCredentials, s as clearMachineId, t as getLatestDaemonLog } from './types-Cezp_n6O.mjs';
-import { spawn, execSync } from 'node:child_process';
-import { resolve, join, dirname as dirname$1 } from 'node:path';
+import { l as logger, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, r as readDaemonState, f as clearDaemonState, p as packageJson, c as configuration, g as readSettings, h as readCredentials, i as encodeBase64, u as updateSettings, j as encodeBase64Url, k as decodeBase64, w as writeCredentials, m as acquireDaemonLock, n as writeDaemonState, A as ApiClient, o as releaseDaemonLock, q as clearCredentials, s as clearMachineId, t as getLatestDaemonLog } from './types-CGbH1LGX.mjs';
+import { spawn, execSync, execFileSync } from 'node:child_process';
+import { resolve, join } from 'node:path';
 import { createInterface } from 'node:readline';
-import { fileURLToPath as fileURLToPath$1 } from 'node:url';
 import { existsSync, readFileSync, mkdirSync, watch, readdirSync, statSync, rmSync } from 'node:fs';
 import { dirname, resolve as resolve$1, join as join$1 } from 'path';
 import { fileURLToPath } from 'url';
@@ -13,6 +12,7 @@ import { readFile } from 'node:fs/promises';
 import fs, { watch as watch$1, access, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { fileURLToPath as fileURLToPath$1 } from 'node:url';
 import axios from 'axios';
 import 'node:events';
 import 'socket.io-client';
@@ -20,17 +20,20 @@ import tweetnacl from 'tweetnacl';
 import 'expo-server-sdk';
 import { spawn as spawn$1, exec, execSync as execSync$1 } from 'child_process';
 import { promisify } from 'util';
-import { createHash } from 'crypto';
+import { createHash, randomBytes as randomBytes$1 } from 'crypto';
+import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import psList from 'ps-list';
+import spawn$2 from 'cross-spawn';
 import os from 'os';
 import qrcode from 'qrcode-terminal';
 import open from 'open';
 import fastify from 'fastify';
 import { z } from 'zod';
 import { validatorCompiler, serializerCompiler } from 'fastify-type-provider-zod';
-import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { createServer as createServer$1 } from 'http';
 
 class Session {
   path;
@@ -40,6 +43,7 @@ class Session {
   queue;
   claudeEnvVars;
   claudeArgs;
+  // Made mutable to allow filtering
   mcpServers;
   allowedTools;
   _onModeChange;
@@ -74,6 +78,11 @@ class Session {
   };
   onSessionFound = (sessionId) => {
     this.sessionId = sessionId;
+    this.client.updateMetadata((metadata) => ({
+      ...metadata,
+      claudeSessionId: sessionId
+    }));
+    logger.debug(`[Session] Claude Code session ID ${sessionId} added to metadata`);
   };
   /**
    * Clear the current session ID (used by /clear command)
@@ -82,6 +91,33 @@ class Session {
     this.sessionId = null;
     logger.debug("[Session] Session ID cleared");
   };
+  /**
+   * Consume one-time Claude flags from claudeArgs after Claude spawn
+   * Currently handles: --resume (with or without session ID)
+   */
+  consumeOneTimeFlags = () => {
+    if (!this.claudeArgs) return;
+    const filteredArgs = [];
+    for (let i = 0; i < this.claudeArgs.length; i++) {
+      if (this.claudeArgs[i] === "--resume") {
+        if (i + 1 < this.claudeArgs.length) {
+          const nextArg = this.claudeArgs[i + 1];
+          if (!nextArg.startsWith("-") && nextArg.includes("-")) {
+            i++;
+            logger.debug(`[Session] Consumed --resume flag with session ID: ${nextArg}`);
+          } else {
+            logger.debug("[Session] Consumed --resume flag (no session ID)");
+          }
+        } else {
+          logger.debug("[Session] Consumed --resume flag (no session ID)");
+        }
+      } else {
+        filteredArgs.push(this.claudeArgs[i]);
+      }
+    }
+    this.claudeArgs = filteredArgs.length > 0 ? filteredArgs : void 0;
+    logger.debug(`[Session] Consumed one-time flags, remaining args:`, this.claudeArgs);
+  };
 }
 
 function getProjectPath(workingDirectory) {
@@ -136,9 +172,19 @@ function trimIdent(text) {
 
 const systemPrompt = trimIdent(`
     ALWAYS when you start a new chat - you must call a tool "mcp__happy__change_title" to set a chat title. When you think chat title is not relevant anymore - call the tool again to change it. When chat name is too generic and you have a change to make it more specific - call the tool again to change it. This title is needed to easily find the chat in the future. Help human.
+
+    When making commit messages, instead of just giving co-credit to Claude, also give credit to Happy like so:
+
+    <main commit message>
+
+    Generated with [Claude Code](https://claude.ai/code)
+    via [Happy](https://happy.engineering)
+
+    Co-Authored-By: Claude <noreply@anthropic.com>
+    Co-Authored-By: Happy <yesreply@happy.engineering>
 `);
 
-dirname$1(fileURLToPath$1(import.meta.url));
+const claudeCliPath = resolve(join(projectPath(), "scripts", "claude_local_launcher.cjs"));
 async function claudeLocal(opts) {
   const projectDir = getProjectPath(opts.path);
   mkdirSync(projectDir, { recursive: true });
@@ -195,7 +241,6 @@ async function claudeLocal(opts) {
       if (opts.claudeArgs) {
         args.push(...opts.claudeArgs);
       }
-      const claudeCliPath = resolve(join(projectPath(), "scripts", "claude_local_launcher.cjs"));
       if (!claudeCliPath || !existsSync(claudeCliPath)) {
         throw new Error("Claude local launcher not found. Please ensure HAPPY_PROJECT_ROOT is set correctly for development.");
       }
@@ -595,6 +640,7 @@ async function claudeLocalLauncher(session) {
           mcpServers: session.mcpServers,
           allowedTools: session.allowedTools
         });
+        session.consumeOneTimeFlags();
         if (!exitReason) {
           exitReason = "exit";
           break;
@@ -1398,6 +1444,26 @@ async function claudeRemote(opts) {
   if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
     startFrom = null;
   }
+  if (!startFrom && opts.claudeArgs) {
+    for (let i = 0; i < opts.claudeArgs.length; i++) {
+      if (opts.claudeArgs[i] === "--resume") {
+        if (i + 1 < opts.claudeArgs.length) {
+          const nextArg = opts.claudeArgs[i + 1];
+          if (!nextArg.startsWith("-") && nextArg.includes("-")) {
+            startFrom = nextArg;
+            logger.debug(`[claudeRemote] Found --resume with session ID: ${startFrom}`);
+            break;
+          } else {
+            logger.debug("[claudeRemote] Found --resume without session ID - not supported in remote mode");
+            break;
+          }
+        } else {
+          logger.debug("[claudeRemote] Found --resume without session ID - not supported in remote mode");
+          break;
+        }
+      }
+    }
+  }
   if (opts.claudeEnvVars) {
     Object.entries(opts.claudeEnvVars).forEach(([key, value]) => {
       process.env[key] = value;
@@ -2586,7 +2652,7 @@ async function claudeRemoteLauncher(session) {
       let modeHash = null;
       let mode = null;
       try {
-        await claudeRemote({
+        const remoteResult = await claudeRemote({
           sessionId: session.sessionId,
           path: session.path,
           allowedTools: session.allowedTools ?? [],
@@ -2647,6 +2713,7 @@ async function claudeRemoteLauncher(session) {
           },
           signal: abortController.signal
         });
+        session.consumeOneTimeFlags();
         if (!exitReason && abortController.signal.aborted) {
           session.client.sendSessionEvent({ type: "message", message: "Aborted by user" });
         }
@@ -2770,7 +2837,7 @@ function run(args, options) {
   });
 }
 
-const execAsync = promisify(exec);
+const execAsync$1 = promisify(exec);
 function registerHandlers(session) {
   session.setHandler("bash", async (data) => {
     logger.debug("Shell command request:", data.command);
@@ -2780,7 +2847,7 @@ function registerHandlers(session) {
         timeout: data.timeout || 3e4
         // Default 30 seconds timeout
       };
-      const { stdout, stderr } = await execAsync(data.command, options);
+      const { stdout, stderr } = await execAsync$1(data.command, options);
       return {
         success: true,
         stdout: stdout ? stdout.toString() : "",
@@ -2979,25 +3046,15 @@ function registerHandlers(session) {
       };
     }
   });
+}
+function registerKillSessionHandler(session, killThisHappy) {
   session.setHandler("killSession", async () => {
     logger.debug("Kill session request received");
-    try {
-      const response = {
-        success: true,
-        message: "Session termination acknowledged, exiting in 100ms"
-      };
-      setTimeout(() => {
-        logger.debug("[KILL SESSION] Exiting process as requested");
-        process.exit(0);
-      }, 100);
-      return response;
-    } catch (error) {
-      logger.debug("Failed to kill session:", error);
-      return {
-        success: false,
-        message: error instanceof Error ? error.message : "Failed to kill session"
-      };
-    }
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
   });
 }
 
@@ -3534,7 +3591,7 @@ async function checkIfDaemonRunningAndCleanupStaleState() {
     return false;
   }
 }
-async function isDaemonRunningSameVersion() {
+async function isDaemonRunningCurrentlyInstalledHappyVersion() {
   logger.debug("[DAEMON CONTROL] Checking if daemon is running same version");
   const runningDaemon = await checkIfDaemonRunningAndCleanupStaleState();
   if (!runningDaemon) {
@@ -3547,8 +3604,11 @@ async function isDaemonRunningSameVersion() {
     return false;
   }
   try {
-    logger.debug(`[DAEMON CONTROL] Current CLI version: ${configuration.currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
-    return configuration.currentCliVersion === state.startedWithCliVersion;
+    const packageJsonPath = join$1(projectPath(), "package.json");
+    const packageJson = JSON.parse(readFileSync$1(packageJsonPath, "utf-8"));
+    const currentCliVersion = packageJson.version;
+    logger.debug(`[DAEMON CONTROL] Current CLI version: ${currentCliVersion}, Daemon started with version: ${state.startedWithCliVersion}`);
+    return currentCliVersion === state.startedWithCliVersion;
   } catch (error) {
     logger.debug("[DAEMON CONTROL] Error checking daemon version", error);
     return false;
@@ -3601,137 +3661,73 @@ async function waitForProcessDeath(pid, timeout) {
   throw new Error("Process did not die within timeout");
 }
 
-function findAllHappyProcesses() {
+async function findAllHappyProcesses() {
   try {
+    const processes = await psList();
     const allProcesses = [];
-    try {
-      const happyOutput = execSync('ps aux | grep -E "(happy\\.mjs|happy-coder|happy-cli.*dist/index\\.mjs)" | grep -v grep', { encoding: "utf8" });
-      const happyLines = happyOutput.trim().split("\n").filter((line) => line.trim());
-      for (const line of happyLines) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length < 11) continue;
-        const pid = parseInt(parts[1]);
-        const command = parts.slice(10).join(" ");
-        let type = "unknown";
-        if (pid === process.pid) {
-          type = "current";
-        } else if (command.includes("--version")) {
-          type = "daemon-version-check";
-        } else if (command.includes("daemon start-sync") || command.includes("daemon start")) {
-          type = "daemon";
-        } else if (command.includes("--started-by daemon")) {
-          type = "daemon-spawned-session";
-        } else if (command.includes("doctor")) {
-          type = "doctor";
-        } else {
-          type = "user-session";
-        }
-        allProcesses.push({ pid, command, type });
-      }
-    } catch {
-    }
-    try {
-      const devOutput = execSync('ps aux | grep -E "tsx.*src/index\\.ts" | grep -v grep', { encoding: "utf8" });
-      const devLines = devOutput.trim().split("\n").filter((line) => line.trim());
-      for (const line of devLines) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length < 11) continue;
-        const pid = parseInt(parts[1]);
-        const command = parts.slice(10).join(" ");
-        if (!command.includes("happy-cli/node_modules/tsx") && !command.includes("/bin/tsx src/index.ts")) {
-          continue;
-        }
-        let type = "unknown";
-        if (pid === process.pid) {
-          type = "current";
-        } else if (command.includes("--version")) {
-          type = "dev-daemon-version-check";
-        } else if (command.includes("daemon start-sync") || command.includes("daemon start")) {
-          type = "dev-daemon";
-        } else if (command.includes("--started-by daemon")) {
-          type = "dev-daemon-spawned";
-        } else if (command.includes("doctor")) {
-          type = "dev-doctor";
-        } else if (command.includes("--yolo")) {
-          type = "dev-session";
-        } else {
-          type = "dev-related";
-        }
-        allProcesses.push({ pid, command, type });
+    for (const proc of processes) {
+      const cmd = proc.cmd || "";
+      const name = proc.name || "";
+      const isHappy = name.includes("happy") || name === "node" && (cmd.includes("happy-cli") || cmd.includes("dist/index.mjs")) || cmd.includes("happy.mjs") || cmd.includes("happy-coder") || cmd.includes("tsx") && cmd.includes("src/index.ts") && cmd.includes("happy-cli");
+      if (!isHappy) continue;
+      let type = "unknown";
+      if (proc.pid === process.pid) {
+        type = "current";
+      } else if (cmd.includes("--version")) {
+        type = cmd.includes("tsx") ? "dev-daemon-version-check" : "daemon-version-check";
+      } else if (cmd.includes("daemon start-sync") || cmd.includes("daemon start")) {
+        type = cmd.includes("tsx") ? "dev-daemon" : "daemon";
+      } else if (cmd.includes("--started-by daemon")) {
+        type = cmd.includes("tsx") ? "dev-daemon-spawned" : "daemon-spawned-session";
+      } else if (cmd.includes("doctor")) {
+        type = cmd.includes("tsx") ? "dev-doctor" : "doctor";
+      } else if (cmd.includes("--yolo")) {
+        type = "dev-session";
+      } else {
+        type = cmd.includes("tsx") ? "dev-related" : "user-session";
       }
-    } catch {
+      allProcesses.push({ pid: proc.pid, command: cmd || name, type });
     }
     return allProcesses;
   } catch (error) {
     return [];
   }
 }
-function findRunawayHappyProcesses() {
-  try {
-    const processes = [];
-    try {
-      const output = execSync('ps aux | grep -E "(happy\\.mjs|happy-coder|happy-cli.*dist/index\\.mjs)" | grep -v grep', { encoding: "utf8" });
-      const lines = output.trim().split("\n").filter((line) => line.trim());
-      for (const line of lines) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length < 11) continue;
-        const pid = parseInt(parts[1]);
-        const command = parts.slice(10).join(" ");
-        if (pid === process.pid) continue;
-        if (command.includes("--started-by daemon") || command.includes("daemon start-sync") || command.includes("daemon start") || command.includes("--version")) {
-          processes.push({ pid, command });
-        }
-      }
-    } catch {
-    }
-    try {
-      const devOutput = execSync('ps aux | grep -E "tsx.*src/index\\.ts" | grep -v grep', { encoding: "utf8" });
-      const devLines = devOutput.trim().split("\n").filter((line) => line.trim());
-      for (const line of devLines) {
-        const parts = line.trim().split(/\s+/);
-        if (parts.length < 11) continue;
-        const pid = parseInt(parts[1]);
-        const command = parts.slice(10).join(" ");
-        if (pid === process.pid) continue;
-        if (!command.includes("happy-cli/node_modules/tsx") && !command.includes("/bin/tsx src/index.ts")) {
-          continue;
-        }
-        if (command.includes("--started-by daemon") || command.includes("daemon start-sync") || command.includes("daemon start") || command.includes("--version")) {
-          processes.push({ pid, command });
-        }
-      }
-    } catch {
-    }
-    return processes;
-  } catch (error) {
-    return [];
-  }
+async function findRunawayHappyProcesses() {
+  const allProcesses = await findAllHappyProcesses();
+  return allProcesses.filter(
+    (p) => p.pid !== process.pid && (p.type === "daemon" || p.type === "dev-daemon" || p.type === "daemon-spawned-session" || p.type === "dev-daemon-spawned" || p.type === "daemon-version-check" || p.type === "dev-daemon-version-check")
+  ).map((p) => ({ pid: p.pid, command: p.command }));
 }
 async function killRunawayHappyProcesses() {
-  const runawayProcesses = findRunawayHappyProcesses();
+  const runawayProcesses = await findRunawayHappyProcesses();
   const errors = [];
-  const killPromises = runawayProcesses.map(async ({ pid, command }) => {
+  let killed = 0;
+  for (const { pid, command } of runawayProcesses) {
     try {
-      process.kill(pid, "SIGTERM");
-      console.log(`Sent SIGTERM to runaway process PID ${pid}: ${command}`);
-      await new Promise((resolve) => setTimeout(resolve, 1e3));
-      try {
-        process.kill(pid, 0);
-        console.log(`Process PID ${pid} ignored SIGTERM, using SIGKILL`);
-        process.kill(pid, "SIGKILL");
-      } catch {
+      console.log(`Killing runaway process PID ${pid}: ${command}`);
+      if (process.platform === "win32") {
+        const result = spawn$2.sync("taskkill", ["/F", "/PID", pid.toString()], { stdio: "pipe" });
+        if (result.error) throw result.error;
+        if (result.status !== 0) throw new Error(`taskkill exited with code ${result.status}`);
+      } else {
+        process.kill(pid, "SIGTERM");
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+        const processes = await psList();
+        const stillAlive = processes.find((p) => p.pid === pid);
+        if (stillAlive) {
+          console.log(`Process PID ${pid} ignored SIGTERM, using SIGKILL`);
+          process.kill(pid, "SIGKILL");
+        }
       }
       console.log(`Successfully killed runaway process PID ${pid}`);
-      return { success: true, pid, command };
+      killed++;
     } catch (error) {
       const errorMessage = error.message;
       errors.push({ pid, error: errorMessage });
       console.log(`Failed to kill process PID ${pid}: ${errorMessage}`);
-      return { success: false, pid, command };
     }
-  });
-  const results = await Promise.all(killPromises);
-  const killed = results.filter((r) => r.success).length;
+  }
   return { killed, errors };
 }
 
@@ -3847,7 +3843,7 @@ async function runDoctorCommand(filter) {
       console.log(chalk.blue(`Location: ${configuration.daemonStateFile}`));
       console.log(chalk.gray(JSON.stringify(state, null, 2)));
     }
-    const allProcesses = findAllHappyProcesses();
+    const allProcesses = await findAllHappyProcesses();
     if (allProcesses.length > 0) {
       console.log(chalk.bold("\n\u{1F50D} All Happy CLI Processes"));
       const grouped = allProcesses.reduce((groups, process2) => {
@@ -4203,31 +4199,54 @@ function startDaemonControlServer({
           sessionId: z.string(),
           metadata: z.any()
           // Metadata type from API
-        })
+        }),
+        response: {
+          200: z.object({
+            status: z.literal("ok")
+          })
+        }
       }
-    }, async (request, reply) => {
+    }, async (request) => {
       const { sessionId, metadata } = request.body;
       logger.debug(`[CONTROL SERVER] Session started: ${sessionId}`);
       onHappySessionWebhook(sessionId, metadata);
       return { status: "ok" };
     });
-    typed.post("/list", async (request, reply) => {
+    typed.post("/list", {
+      schema: {
+        response: {
+          200: z.object({
+            children: z.array(z.object({
+              startedBy: z.string(),
+              happySessionId: z.string(),
+              pid: z.number()
+            }))
+          })
+        }
+      }
+    }, async () => {
       const children = getChildren();
       logger.debug(`[CONTROL SERVER] Listing ${children.length} sessions`);
       return {
-        children: children.map((child) => {
-          delete child.childProcess;
-          return child;
-        })
+        children: children.filter((child) => child.happySessionId !== void 0).map((child) => ({
+          startedBy: child.startedBy,
+          happySessionId: child.happySessionId,
+          pid: child.pid
+        }))
       };
     });
     typed.post("/stop-session", {
       schema: {
         body: z.object({
           sessionId: z.string()
-        })
+        }),
+        response: {
+          200: z.object({
+            success: z.boolean()
+          })
+        }
       }
-    }, async (request, reply) => {
+    }, async (request) => {
       const { sessionId } = request.body;
       logger.debug(`[CONTROL SERVER] Stop session request: ${sessionId}`);
       const success = stopSession(sessionId);
@@ -4238,28 +4257,68 @@ function startDaemonControlServer({
         body: z.object({
           directory: z.string(),
           sessionId: z.string().optional()
-        })
+        }),
+        response: {
+          200: z.object({
+            success: z.boolean(),
+            sessionId: z.string().optional(),
+            approvedNewDirectoryCreation: z.boolean().optional()
+          }),
+          409: z.object({
+            success: z.boolean(),
+            requiresUserApproval: z.boolean().optional(),
+            actionRequired: z.string().optional(),
+            directory: z.string().optional()
+          }),
+          500: z.object({
+            success: z.boolean(),
+            error: z.string().optional()
+          })
+        }
       }
     }, async (request, reply) => {
       const { directory, sessionId } = request.body;
       logger.debug(`[CONTROL SERVER] Spawn session request: dir=${directory}, sessionId=${sessionId || "new"}`);
-      const session = await spawnSession(directory, sessionId);
-      if (session) {
-        return {
-          success: true,
-          pid: session.pid,
-          sessionId: session.happySessionId || "pending",
-          message: session.message
-        };
-      } else {
-        reply.code(500);
-        return {
-          success: false,
-          error: "Failed to spawn session. Check the directory path and permissions."
-        };
+      const result = await spawnSession({ directory, sessionId });
+      switch (result.type) {
+        case "success":
+          if (!result.sessionId) {
+            reply.code(500);
+            return {
+              success: false,
+              error: "Failed to spawn session: no session ID returned"
+            };
+          }
+          return {
+            success: true,
+            sessionId: result.sessionId,
+            approvedNewDirectoryCreation: true
+          };
+        case "requestToApproveDirectoryCreation":
+          reply.code(409);
+          return {
+            success: false,
+            requiresUserApproval: true,
+            actionRequired: "CREATE_DIRECTORY",
+            directory: result.directory
+          };
+        case "error":
+          reply.code(500);
+          return {
+            success: false,
+            error: result.errorMessage
+          };
       }
     });
-    typed.post("/stop", async (request, reply) => {
+    typed.post("/stop", {
+      schema: {
+        response: {
+          200: z.object({
+            status: z.string()
+          })
+        }
+      }
+    }, async () => {
       logger.debug("[CONTROL SERVER] Stop daemon request received");
       setTimeout(() => {
         logger.debug("[CONTROL SERVER] Triggering daemon shutdown");
@@ -4267,21 +4326,6 @@ function startDaemonControlServer({
       }, 50);
       return { status: "stopping" };
     });
-    typed.post("/dev-simulate-error", {
-      schema: {
-        body: z.object({
-          error: z.string()
-        })
-      }
-    }, async (request, reply) => {
-      const { error } = request.body;
-      logger.debug(`[CONTROL SERVER] Dev: Simulating error: ${error}`);
-      setTimeout(() => {
-        logger.debug(`[CONTROL SERVER] Dev: Throwing simulated error now`);
-        throw new Error(error);
-      }, 100);
-      return { status: "error will be thrown" };
-    });
     app.listen({ port: 0, host: "127.0.0.1" }, (err, address) => {
       if (err) {
         logger.debug("[CONTROL SERVER] Failed to start:", err);
@@ -4349,7 +4393,7 @@ async function startDaemon() {
   });
   logger.debug("[DAEMON RUN] Starting daemon process...");
   logger.debugLargeJson("[DAEMON RUN] Environment", getEnvironmentInfo());
-  const runningDaemonVersionMatches = await isDaemonRunningSameVersion();
+  const runningDaemonVersionMatches = await isDaemonRunningCurrentlyInstalledHappyVersion();
   if (!runningDaemonVersionMatches) {
     logger.debug("[DAEMON RUN] Daemon version mismatch detected, restarting daemon with current CLI version");
     await stopDaemon();
@@ -4404,16 +4448,22 @@ async function startDaemon() {
         logger.debug(`[DAEMON RUN] Registered externally-started session ${sessionId}`);
       }
     };
-    const spawnSession = async (directory, sessionId) => {
+    const spawnSession = async (options) => {
+      logger.debugLargeJson("[DAEMON RUN] Spawning session", options);
+      const { directory, sessionId, machineId: machineId2, approvedNewDirectoryCreation = true } = options;
       let directoryCreated = false;
-      if (directory.startsWith("~")) {
-        directory = resolve$1(os.homedir(), directory.replace("~", ""));
-      }
       try {
         await fs.access(directory);
         logger.debug(`[DAEMON RUN] Directory exists: ${directory}`);
       } catch (error) {
         logger.debug(`[DAEMON RUN] Directory doesn't exist, creating: ${directory}`);
+        if (!approvedNewDirectoryCreation) {
+          logger.debug(`[DAEMON RUN] Directory creation not approved for: ${directory}`);
+          return {
+            type: "requestToApproveDirectoryCreation",
+            directory
+          };
+        }
         try {
           await fs.mkdir(directory, { recursive: true });
           logger.debug(`[DAEMON RUN] Successfully created directory: ${directory}`);
@@ -4432,7 +4482,10 @@ async function startDaemon() {
             errorMessage += `System error: ${mkdirError.message || mkdirError}. Please verify the path is valid and you have the necessary permissions.`;
           }
           logger.debug(`[DAEMON RUN] Directory creation failed: ${errorMessage}`);
-          return null;
+          return {
+            type: "error",
+            errorMessage
+          };
         }
       }
       try {
@@ -4460,7 +4513,10 @@ async function startDaemon() {
         }
         if (!happyProcess.pid) {
           logger.debug("[DAEMON RUN] Failed to spawn process - no PID returned");
-          return null;
+          return {
+            type: "error",
+            errorMessage: "Failed to spawn Happy process - no PID returned"
+          };
         }
         logger.debug(`[DAEMON RUN] Spawned process with PID ${happyProcess.pid}`);
         const trackedSession = {
@@ -4488,17 +4544,27 @@ async function startDaemon() {
           const timeout = setTimeout(() => {
             pidToAwaiter.delete(happyProcess.pid);
             logger.debug(`[DAEMON RUN] Session webhook timeout for PID ${happyProcess.pid}`);
-            resolve2(trackedSession);
+            resolve2({
+              type: "error",
+              errorMessage: `Session webhook timeout for PID ${happyProcess.pid}`
+            });
           }, 1e4);
           pidToAwaiter.set(happyProcess.pid, (completedSession) => {
             clearTimeout(timeout);
             logger.debug(`[DAEMON RUN] Session ${completedSession.happySessionId} fully spawned with webhook`);
-            resolve2(completedSession);
+            resolve2({
+              type: "success",
+              sessionId: completedSession.happySessionId
+            });
           });
         });
       } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
         logger.debug("[DAEMON RUN] Failed to spawn session:", error);
-        return null;
+        return {
+          type: "error",
+          errorMessage: `Failed to spawn session: ${errorMessage}`
+        };
       }
     };
     const stopSession = (sessionId) => {
@@ -4769,7 +4835,10 @@ async function start(credentials, options = {}) {
     happyHomeDir: configuration.happyHomeDir,
     startedFromDaemon: options.startedBy === "daemon",
     hostPid: process.pid,
-    startedBy: options.startedBy || "terminal"
+    startedBy: options.startedBy || "terminal",
+    // Initialize lifecycle state
+    lifecycleState: "running",
+    lifecycleStateSince: Date.now()
   };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
   logger.debug(`Session created: ${response.id}`);
@@ -4937,6 +5006,13 @@ async function start(credentials, options = {}) {
     logger.debug("[START] Received termination signal, cleaning up...");
     try {
       if (session) {
+        session.updateMetadata((currentMetadata) => ({
+          ...currentMetadata,
+          lifecycleState: "archived",
+          lifecycleStateSince: Date.now(),
+          archivedBy: "cli",
+          archiveReason: "User terminated"
+        }));
         session.sendSessionDeath();
         await session.flush();
         await session.close();
@@ -4960,6 +5036,7 @@ async function start(credentials, options = {}) {
     logger.debug("[START] Unhandled rejection:", reason);
     cleanup();
   });
+  registerKillSessionHandler(session, cleanup);
   await loop({
     path: workingDirectory,
     model: options.model,
@@ -4975,7 +5052,7 @@ async function start(credentials, options = {}) {
         controlledByUser: newMode === "local"
       }));
     },
-    onSessionReady: (sessionInstance) => {
+    onSessionReady: (_sessionInstance) => {
     },
     mcpServers: {
       "happy": {
@@ -5164,19 +5241,12 @@ ${chalk.bold("Usage:")}
   happy auth login [--force]    Authenticate with Happy
   happy auth logout             Remove authentication and machine data  
   happy auth status             Show authentication status
-  happy auth show-backup        Display backup key for mobile/web clients
+  happy auth backup             Display backup key for mobile/web clients
   happy auth help               Show this help message
 
 ${chalk.bold("Options:")}
   --force    Clear credentials, machine ID, and stop daemon before re-auth
 
-${chalk.bold("Examples:")}
-  happy auth login              Authenticate if not already logged in
-  happy auth login --force      Force re-authentication (complete reset)
-  happy auth status             Check authentication and machine status
-  happy auth show-backup        Get backup key to link other devices
-  happy auth logout             Remove all authentication data
-
 ${chalk.bold("Notes:")} 
   \u2022 Use 'auth login --force' when you need to re-register your machine
   \u2022 'auth show-backup' displays the key format expected by mobile/web clients
@@ -5324,33 +5394,561 @@ async function handleAuthStatus() {
   }
 }
 
-const DaemonPrompt = ({ onSelect }) => {
-  const [selectedIndex, setSelectedIndex] = useState(0);
-  const options = [
-    { value: true, label: "Yes (recommended)", key: "Y" },
-    { value: false, label: "No", key: "N" }
-  ];
-  useInput((input, key) => {
-    const upperInput = input.toUpperCase();
-    if (key.upArrow || key.leftArrow) {
-      setSelectedIndex(0);
-    } else if (key.downArrow || key.rightArrow) {
-      setSelectedIndex(1);
-    } else if (key.return) {
-      onSelect(options[selectedIndex].value);
-    } else if (upperInput === "Y") {
-      onSelect(true);
-    } else if (upperInput === "N") {
-      onSelect(false);
-    } else if (key.escape || key.ctrl && input === "c") {
-      onSelect(false);
+const CLIENT_ID$2 = "app_EMoamEEZ73f0CkXaXp7hrann";
+const AUTH_BASE_URL = "https://auth.openai.com";
+const DEFAULT_PORT$2 = 1455;
+function generatePKCE$2() {
+  const verifier = randomBytes$1(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
+  const challenge = createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return { verifier, challenge };
+}
+function generateState$2() {
+  return randomBytes$1(16).toString("hex");
+}
+function parseJWT(token) {
+  const parts = token.split(".");
+  if (parts.length !== 3) {
+    throw new Error("Invalid JWT format");
+  }
+  const payload = Buffer.from(parts[1], "base64url").toString();
+  return JSON.parse(payload);
+}
+async function findAvailablePort$2() {
+  return new Promise((resolve) => {
+    const server = createServer$1();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+  });
+}
+async function isPortAvailable$2(port) {
+  return new Promise((resolve) => {
+    const testServer = createServer$1();
+    testServer.once("error", () => {
+      testServer.close();
+      resolve(false);
+    });
+    testServer.listen(port, "127.0.0.1", () => {
+      testServer.close(() => resolve(true));
+    });
+  });
+}
+async function exchangeCodeForTokens$2(code, verifier, port) {
+  const response = await fetch(`${AUTH_BASE_URL}/oauth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID$2,
+      code,
+      code_verifier: verifier,
+      redirect_uri: `http://localhost:${port}/auth/callback`
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${error}`);
+  }
+  const data = await response.json();
+  const idTokenPayload = parseJWT(data.id_token);
+  let accountId = idTokenPayload.chatgpt_account_id;
+  if (!accountId) {
+    const authClaim = idTokenPayload["https://api.openai.com/auth"];
+    if (authClaim && typeof authClaim === "object") {
+      accountId = authClaim.chatgpt_account_id || authClaim.account_id;
     }
+  }
+  return {
+    id_token: data.id_token,
+    access_token: data.access_token || data.id_token,
+    refresh_token: data.refresh_token,
+    account_id: accountId
+  };
+}
+async function startCallbackServer$2(state, verifier, port) {
+  return new Promise((resolve, reject) => {
+    const server = createServer$1(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/auth/callback") {
+        const code = url.searchParams.get("code");
+        const receivedState = url.searchParams.get("state");
+        if (receivedState !== state) {
+          res.writeHead(400);
+          res.end("Invalid state parameter");
+          server.close();
+          reject(new Error("Invalid state parameter"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("No authorization code received");
+          server.close();
+          reject(new Error("No authorization code received"));
+          return;
+        }
+        try {
+          const tokens = await exchangeCodeForTokens$2(code, verifier, port);
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(`
+                        <html>
+                        <body style="font-family: sans-serif; padding: 20px;">
+                            <h2>\u2705 Authentication Successful!</h2>
+                            <p>You can close this window and return to your terminal.</p>
+                            <script>setTimeout(() => window.close(), 3000);<\/script>
+                        </body>
+                        </html>
+                    `);
+          server.close();
+          resolve(tokens);
+        } catch (error) {
+          res.writeHead(500);
+          res.end("Token exchange failed");
+          server.close();
+          reject(error);
+        }
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout"));
+    }, 5 * 60 * 1e3);
   });
-  return /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, { bold: true, color: "cyan" }, "\u{1F680} Happy Daemon Setup")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column", marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "\u{1F4F1} Happy can run a background service that allows you to:"), /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "  \u2022 Spawn new conversations from your phone"), /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "  \u2022 Continue closed conversations remotely"), /* @__PURE__ */ React.createElement(Text, { color: "cyan" }, "  \u2022 Work with Claude while your computer has internet")), /* @__PURE__ */ React.createElement(Box, { marginBottom: 1 }, /* @__PURE__ */ React.createElement(Text, null, "Would you like Happy to start this service automatically?")), /* @__PURE__ */ React.createElement(Box, { flexDirection: "column" }, options.map((option, index) => {
-    const isSelected = selectedIndex === index;
-    return /* @__PURE__ */ React.createElement(Box, { key: option.key }, /* @__PURE__ */ React.createElement(Text, { color: isSelected ? "green" : "gray" }, isSelected ? "\u203A " : "  ", "[", option.key, "] ", option.label));
-  })), /* @__PURE__ */ React.createElement(Box, { marginTop: 1 }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, "Press Y/N or use arrows + Enter to select")));
-};
+}
+async function authenticateCodex() {
+  const { verifier, challenge } = generatePKCE$2();
+  const state = generateState$2();
+  let port = DEFAULT_PORT$2;
+  const portAvailable = await isPortAvailable$2(port);
+  if (!portAvailable) {
+    port = await findAvailablePort$2();
+  }
+  const serverPromise = startCallbackServer$2(state, verifier, port);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const redirect_uri = `http://localhost:${port}/auth/callback`;
+  const params = [
+    ["response_type", "code"],
+    ["client_id", CLIENT_ID$2],
+    ["redirect_uri", redirect_uri],
+    ["scope", "openid profile email offline_access"],
+    ["code_challenge", challenge],
+    ["code_challenge_method", "S256"],
+    ["id_token_add_organizations", "true"],
+    ["codex_cli_simplified_flow", "true"],
+    ["state", state]
+  ];
+  const queryString = params.map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("&");
+  const authUrl = `${AUTH_BASE_URL}/oauth/authorize?${queryString}`;
+  console.log("\u{1F4CB} Opening browser for authentication...");
+  console.log(`If browser doesn't open, visit:
+${authUrl}
+`);
+  await openBrowser(authUrl);
+  const tokens = await serverPromise;
+  console.log("\u{1F389} Authentication successful!");
+  return tokens;
+}
+
+const CLIENT_ID$1 = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+const CLAUDE_AI_AUTHORIZE_URL = "https://claude.ai/oauth/authorize";
+const TOKEN_URL$1 = "https://console.anthropic.com/v1/oauth/token";
+const DEFAULT_PORT$1 = 54545;
+const SCOPE = "user:inference";
+function generatePKCE$1() {
+  const verifier = randomBytes$1(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
+  const challenge = createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return { verifier, challenge };
+}
+function generateState$1() {
+  return randomBytes$1(32).toString("base64url");
+}
+async function findAvailablePort$1() {
+  return new Promise((resolve) => {
+    const server = createServer$1();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+  });
+}
+async function isPortAvailable$1(port) {
+  return new Promise((resolve) => {
+    const testServer = createServer$1();
+    testServer.once("error", () => {
+      testServer.close();
+      resolve(false);
+    });
+    testServer.listen(port, "127.0.0.1", () => {
+      testServer.close(() => resolve(true));
+    });
+  });
+}
+async function exchangeCodeForTokens$1(code, verifier, port, state) {
+  const tokenResponse = await fetch(TOKEN_URL$1, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: `http://localhost:${port}/callback`,
+      client_id: CLIENT_ID$1,
+      code_verifier: verifier,
+      state
+    })
+  });
+  if (!tokenResponse.ok) {
+    throw new Error(`Token exchange failed: ${tokenResponse.statusText}`);
+  }
+  const tokenData = await tokenResponse.json();
+  return {
+    raw: tokenData,
+    token: tokenData.access_token,
+    expires: Date.now() + tokenData.expires_in * 1e3
+  };
+}
+async function startCallbackServer$1(state, verifier, port) {
+  return new Promise((resolve, reject) => {
+    const server = createServer$1(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/callback") {
+        const code = url.searchParams.get("code");
+        const receivedState = url.searchParams.get("state");
+        if (receivedState !== state) {
+          res.writeHead(400);
+          res.end("Invalid state parameter");
+          server.close();
+          reject(new Error("Invalid state parameter"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("No authorization code received");
+          server.close();
+          reject(new Error("No authorization code received"));
+          return;
+        }
+        try {
+          const tokens = await exchangeCodeForTokens$1(code, verifier, port, state);
+          res.writeHead(302, {
+            "Location": "https://console.anthropic.com/oauth/code/success?app=claude-code"
+          });
+          res.end();
+          server.close();
+          resolve(tokens);
+        } catch (error) {
+          res.writeHead(500);
+          res.end("Token exchange failed");
+          server.close();
+          reject(error);
+        }
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function authenticateClaude() {
+  console.log("\u{1F680} Starting Anthropic Claude authentication...");
+  const { verifier, challenge } = generatePKCE$1();
+  const state = generateState$1();
+  let port = DEFAULT_PORT$1;
+  const portAvailable = await isPortAvailable$1(port);
+  if (!portAvailable) {
+    console.log(`Port ${port} is in use, finding an available port...`);
+    port = await findAvailablePort$1();
+  }
+  console.log(`\u{1F4E1} Using callback port: ${port}`);
+  const serverPromise = startCallbackServer$1(state, verifier, port);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const redirect_uri = `http://localhost:${port}/callback`;
+  const params = new URLSearchParams({
+    code: "true",
+    // This tells Claude.ai to show the code AND redirect
+    client_id: CLIENT_ID$1,
+    response_type: "code",
+    redirect_uri,
+    scope: SCOPE,
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state
+  });
+  const authUrl = `${CLAUDE_AI_AUTHORIZE_URL}?${params}`;
+  console.log("\u{1F4CB} Opening browser for authentication...");
+  console.log("If browser doesn't open, visit this URL:");
+  console.log();
+  console.log(`${authUrl}`);
+  console.log();
+  await openBrowser(authUrl);
+  try {
+    const tokens = await serverPromise;
+    console.log("\u{1F389} Authentication successful!");
+    console.log("\u2705 OAuth tokens received");
+    return tokens;
+  } catch (error) {
+    console.error("\n\u274C Failed to authenticate with Anthropic");
+    throw error;
+  }
+}
+
+const execAsync = promisify(exec);
+const CLIENT_ID = "681255809395-oo8ft2oprdrnp9e3aqf6av3hmdib135j.apps.googleusercontent.com";
+const CLIENT_SECRET = "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";
+const AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+const TOKEN_URL = "https://oauth2.googleapis.com/token";
+const DEFAULT_PORT = 54545;
+const SCOPES = [
+  "https://www.googleapis.com/auth/cloud-platform",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile"
+].join(" ");
+function generatePKCE() {
+  const verifier = randomBytes$1(32).toString("base64url").replace(/[^a-zA-Z0-9\-._~]/g, "");
+  const challenge = createHash("sha256").update(verifier).digest("base64url").replace(/=/g, "").replace(/\+/g, "-").replace(/\//g, "_");
+  return { verifier, challenge };
+}
+function generateState() {
+  return randomBytes$1(32).toString("hex");
+}
+async function findAvailablePort() {
+  return new Promise((resolve) => {
+    const server = createServer$1();
+    server.listen(0, "127.0.0.1", () => {
+      const port = server.address().port;
+      server.close(() => resolve(port));
+    });
+  });
+}
+async function isPortAvailable(port) {
+  return new Promise((resolve) => {
+    const testServer = createServer$1();
+    testServer.once("error", () => {
+      testServer.close();
+      resolve(false);
+    });
+    testServer.listen(port, "127.0.0.1", () => {
+      testServer.close(() => resolve(true));
+    });
+  });
+}
+async function exchangeCodeForTokens(code, verifier, port) {
+  const response = await fetch(TOKEN_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: new URLSearchParams({
+      grant_type: "authorization_code",
+      client_id: CLIENT_ID,
+      client_secret: CLIENT_SECRET,
+      code,
+      code_verifier: verifier,
+      redirect_uri: `http://localhost:${port}/oauth2callback`
+    })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Token exchange failed: ${error}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function startCallbackServer(state, verifier, port) {
+  return new Promise((resolve, reject) => {
+    const server = createServer$1(async (req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname === "/oauth2callback") {
+        const code = url.searchParams.get("code");
+        const receivedState = url.searchParams.get("state");
+        const error = url.searchParams.get("error");
+        if (error) {
+          res.writeHead(302, {
+            "Location": "https://developers.google.com/gemini-code-assist/auth_failure_gemini"
+          });
+          res.end();
+          server.close();
+          reject(new Error(`Authentication error: ${error}`));
+          return;
+        }
+        if (receivedState !== state) {
+          res.writeHead(400);
+          res.end("State mismatch. Possible CSRF attack");
+          server.close();
+          reject(new Error("Invalid state parameter"));
+          return;
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("No authorization code received");
+          server.close();
+          reject(new Error("No authorization code received"));
+          return;
+        }
+        try {
+          const tokens = await exchangeCodeForTokens(code, verifier, port);
+          res.writeHead(302, {
+            "Location": "https://developers.google.com/gemini-code-assist/auth_success_gemini"
+          });
+          res.end();
+          server.close();
+          resolve(tokens);
+        } catch (error2) {
+          res.writeHead(500);
+          res.end("Token exchange failed");
+          server.close();
+          reject(error2);
+        }
+      }
+    });
+    server.listen(port, "127.0.0.1", () => {
+    });
+    setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timeout"));
+    }, 5 * 60 * 1e3);
+  });
+}
+async function authenticateGemini() {
+  console.log("\u{1F680} Starting Google Gemini authentication...");
+  const { verifier, challenge } = generatePKCE();
+  const state = generateState();
+  let port = DEFAULT_PORT;
+  const portAvailable = await isPortAvailable(port);
+  if (!portAvailable) {
+    console.log(`Port ${port} is in use, finding an available port...`);
+    port = await findAvailablePort();
+  }
+  console.log(`\u{1F4E1} Using callback port: ${port}`);
+  const serverPromise = startCallbackServer(state, verifier, port);
+  await new Promise((resolve) => setTimeout(resolve, 100));
+  const redirect_uri = `http://localhost:${port}/oauth2callback`;
+  const params = new URLSearchParams({
+    client_id: CLIENT_ID,
+    response_type: "code",
+    redirect_uri,
+    scope: SCOPES,
+    access_type: "offline",
+    // To get refresh token
+    code_challenge: challenge,
+    code_challenge_method: "S256",
+    state,
+    prompt: "consent"
+    // Force consent to get refresh token
+  });
+  const authUrl = `${AUTHORIZE_URL}?${params}`;
+  console.log("\n\u{1F4CB} Opening browser for authentication...");
+  console.log("If browser doesn't open, visit this URL:");
+  console.log(`
+${authUrl}
+`);
+  const platform = process.platform;
+  const openCommand = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  try {
+    await execAsync(`${openCommand} "${authUrl}"`);
+  } catch {
+    console.log("\u26A0\uFE0F  Could not open browser automatically");
+  }
+  try {
+    const tokens = await serverPromise;
+    console.log("\n\u{1F389} Authentication successful!");
+    console.log("\u2705 OAuth tokens received");
+    return tokens;
+  } catch (error) {
+    console.error("\n\u274C Failed to authenticate with Google");
+    throw error;
+  }
+}
+
+async function handleConnectCommand(args) {
+  const subcommand = args[0];
+  if (!subcommand || subcommand === "help" || subcommand === "--help" || subcommand === "-h") {
+    showConnectHelp();
+    return;
+  }
+  switch (subcommand.toLowerCase()) {
+    case "codex":
+      await handleConnectVendor("codex", "OpenAI");
+      break;
+    case "claude":
+      await handleConnectVendor("claude", "Anthropic");
+      break;
+    case "gemini":
+      await handleConnectVendor("gemini", "Gemini");
+      break;
+    default:
+      console.error(chalk.red(`Unknown connect target: ${subcommand}`));
+      showConnectHelp();
+      process.exit(1);
+  }
+}
+function showConnectHelp() {
+  console.log(`
+${chalk.bold("happy connect")} - Connect AI vendor API keys to Happy cloud
+
+${chalk.bold("Usage:")}
+  happy connect codex        Store your Codex API key in Happy cloud
+  happy connect anthropic    Store your Anthropic API key in Happy cloud
+  happy connect gemini       Store your Gemini API key in Happy cloud
+  happy connect help         Show this help message
+
+${chalk.bold("Description:")}
+  The connect command allows you to securely store your AI vendor API keys
+  in Happy cloud. This enables you to use these services through Happy
+  without exposing your API keys locally.
+
+${chalk.bold("Examples:")}
+  happy connect codex
+  happy connect anthropic
+  happy connect gemini
+
+${chalk.bold("Notes:")} 
+  \u2022 You must be authenticated with Happy first (run 'happy auth login')
+  \u2022 API keys are encrypted and stored securely in Happy cloud
+  \u2022 You can manage your stored keys at app.happy.engineering
+`);
+}
+async function handleConnectVendor(vendor, displayName) {
+  console.log(chalk.bold(`
+\u{1F50C} Connecting ${displayName} to Happy cloud
+`));
+  const credentials = await readCredentials();
+  if (!credentials) {
+    console.log(chalk.yellow("\u26A0\uFE0F  Not authenticated with Happy"));
+    console.log(chalk.gray('  Please run "happy auth login" first'));
+    process.exit(1);
+  }
+  const api = new ApiClient(credentials.token, credentials.secret);
+  if (vendor === "codex") {
+    console.log("\u{1F680} Registering Codex token with server");
+    const codexAuthTokens = await authenticateCodex();
+    await api.registerVendorToken("openai", { oauth: codexAuthTokens });
+    console.log("\u2705 Codex token registered with server");
+    process.exit(0);
+  } else if (vendor === "claude") {
+    console.log("\u{1F680} Registering Anthropic token with server");
+    const anthropicAuthTokens = await authenticateClaude();
+    await api.registerVendorToken("anthropic", { oauth: anthropicAuthTokens });
+    console.log("\u2705 Anthropic token registered with server");
+    process.exit(0);
+  } else if (vendor === "gemini") {
+    console.log("\u{1F680} Registering Gemini token with server");
+    const geminiAuthTokens = await authenticateGemini();
+    await api.registerVendorToken("gemini", { oauth: geminiAuthTokens });
+    console.log("\u2705 Gemini token registered with server");
+    process.exit(0);
+  } else {
+    throw new Error(`Unsupported vendor: ${vendor}`);
+  }
+}
 
 (async () => {
   const args = process.argv.slice(2);
@@ -5380,6 +5978,17 @@ const DaemonPrompt = ({ onSelect }) => {
       process.exit(1);
     }
     return;
+  } else if (subcommand === "connect") {
+    try {
+      await 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 === "logout") {
     console.log(chalk.yellow('Note: "happy logout" is deprecated. Use "happy auth logout" instead.\n'));
     try {
@@ -5516,7 +6125,7 @@ ${chalk.bold("To clean up runaway processes:")} Use ${chalk.cyan("happy doctor c
       } else if (arg === "-v" || arg === "--version") {
         showVersion = true;
         unknownArgs.push(arg);
-      } else if (arg === "--auth" || arg === "--login") ; else if (arg === "--force-auth") ; else if (arg === "--happy-starting-mode") {
+      } else if (arg === "--happy-starting-mode") {
         options.startingMode = z.enum(["local", "remote"]).parse(args[++i]);
       } else if (arg === "--yolo") {
         unknownArgs.push("--dangerously-skip-permissions");
@@ -5545,22 +6154,21 @@ ${chalk.bold("Usage:")}
 
 ${chalk.bold("Examples:")}
   happy                    Start session
-  happy --yolo             Bypass permissions
-  happy --verbose          Enable verbose mode
+  happy --yolo             Start with bypassing permissions 
+                            happy sugar for --dangerously-skip-permissions
   happy auth login --force Authenticate
   happy doctor             Run diagnostics
 
-${chalk.bold("Happy is a wrapper around Claude Code that enables remote control via mobile app.")}
-
 ${chalk.bold("Happy supports ALL Claude options!")}
-  Use any claude flag exactly as you normally would.
+  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`):")}
 `);
-      const { execSync } = await import('child_process');
       try {
-        const claudeHelp = execSync("claude --help", { encoding: "utf8" });
+        const claudeHelp = execFileSync(process.execPath, [claudeCliPath, "--help"], { encoding: "utf8" });
         console.log(claudeHelp);
       } catch (e) {
         console.log(chalk.yellow("Could not retrieve claude help. Make sure claude is installed."));
@@ -5568,53 +6176,21 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
       process.exit(0);
     }
     if (showVersion) {
-      console.log(packageJson.version);
-      process.exit(0);
+      console.log(`happy version: ${packageJson.version}`);
     }
     const {
       credentials
     } = await authAndSetupMachineIfNeeded();
-    let settings = await readSettings();
-    if (settings && settings.daemonAutoStartWhenRunningHappy === void 0) {
-      const shouldAutoStart = await new Promise((resolve) => {
-        let hasResolved = false;
-        const onSelect = (autoStart) => {
-          if (!hasResolved) {
-            hasResolved = true;
-            app.unmount();
-            resolve(autoStart);
-          }
-        };
-        const app = render(React.createElement(DaemonPrompt, { onSelect }), {
-          exitOnCtrlC: false,
-          patchConsole: false
-        });
+    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
       });
-      settings = await updateSettings((settings2) => ({
-        ...settings2,
-        daemonAutoStartWhenRunningHappy: shouldAutoStart
-      }));
-      if (shouldAutoStart) {
-        console.log(chalk.green("\n\u2713 Happy will start the background service automatically"));
-        console.log(chalk.gray("  The service will run whenever you use the happy command"));
-      } else {
-        console.log(chalk.yellow("\n  You can enable this later by running: happy daemon install"));
-      }
-    }
-    if (settings && settings.daemonAutoStartWhenRunningHappy) {
-      logger.debug("Ensuring Happy background service is running & matches our version...");
-      if (!await isDaemonRunningSameVersion()) {
-        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, 100));
-      } else {
-        logger.debug("Happy background service is running & matches our version");
-      }
+      daemonProcess.unref();
+      await new Promise((resolve) => setTimeout(resolve, 200));
     }
     try {
       await start(credentials, options);