happy-coder 0.9.1 → 0.10.0-1

package/dist/index.mjs

@@ -1,36 +1,39 @@
 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-BS8Pr3Im.mjs';
-import { spawn, execSync } from 'node:child_process';
-import { resolve, join, dirname as dirname$1 } from 'node:path';
+import { l as logger, p as projectPath, b as backoff, d as delay, R as RawJSONLinesSchema, e as AsyncLock, r as readDaemonState, f as clearDaemonState, g as packageJson, c as configuration, h as readSettings, i as readCredentials, j as encodeBase64, u as updateSettings, k as encodeBase64Url, m as decodeBase64, w as writeCredentials, n as acquireDaemonLock, o as writeDaemonState, A as ApiClient, q as releaseDaemonLock, s as clearCredentials, t as clearMachineId, v as getLatestDaemonLog } from './types-BUXwivpV.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';
 import { readFile } from 'node:fs/promises';
-import fs, { watch as watch$1, access, readFile as readFile$1, stat, writeFile, readdir } from 'fs/promises';
+import fs, { watch as watch$1, access } from 'fs/promises';
 import { useStdout, useInput, Box, Text, render } from 'ink';
 import React, { useState, useRef, useEffect, useCallback } from 'react';
+import { fileURLToPath } from 'node:url';
 import axios from 'axios';
 import 'node:events';
 import 'socket.io-client';
 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 { spawn as spawn$1, execSync as execSync$1, exec } from 'child_process';
+import { readFileSync as readFileSync$1, existsSync as existsSync$1, writeFileSync, chmodSync, unlinkSync } from 'fs';
+import { join as join$1 } from 'path';
+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';
+import { promisify } from 'util';
+import 'url';
 
 class Session {
   path;
@@ -142,12 +145,6 @@ function claudeCheckSession(sessionId, path) {
   return hasGoodMessage;
 }
 
-const __dirname$1 = dirname(fileURLToPath(import.meta.url));
-function projectPath() {
-  const path = resolve$1(__dirname$1, "..");
-  return path;
-}
-
 function trimIdent(text) {
   const lines = text.split("\n");
   while (lines.length > 0 && lines[0].trim() === "") {
@@ -181,7 +178,7 @@ const systemPrompt = trimIdent(`
     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 });
@@ -238,7 +235,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.");
       }
@@ -609,8 +605,8 @@ async function claudeLocalLauncher(session) {
       }
       await abort();
     }
-    session.client.setHandler("abort", doAbort);
-    session.client.setHandler("switch", doSwitch);
+    session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+    session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
     session.queue.setOnMessage((message, mode) => {
       doSwitch();
     });
@@ -656,9 +652,9 @@ async function claudeLocalLauncher(session) {
     }
   } finally {
     exutFuture.resolve(void 0);
-    session.client.setHandler("abort", async () => {
+    session.client.rpcHandlerManager.registerHandler("abort", async () => {
     });
-    session.client.setHandler("switch", async () => {
+    session.client.rpcHandlerManager.registerHandler("switch", async () => {
     });
     session.queue.setOnMessage(null);
     await scanner.cleanup();
@@ -925,7 +921,7 @@ class AbortError extends Error {
   }
 }
 
-const __filename = fileURLToPath$1(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
 const __dirname = join(__filename, "..");
 function getDefaultClaudeCodePath() {
   return join(__dirname, "..", "..", "..", "node_modules", "@anthropic-ai", "claude-code", "cli.js");
@@ -1920,7 +1916,7 @@ class PermissionHandler {
    * Sets up the client handler for permission responses
    */
   setupClientHandler() {
-    this.session.client.setHandler("permission", async (message) => {
+    this.session.client.rpcHandlerManager.registerHandler("permission", async (message) => {
       logger.debug(`Permission response: ${JSON.stringify(message)}`);
       const id = message.id;
       const pending = this.pendingRequests.get(id);
@@ -2490,8 +2486,8 @@ async function claudeRemoteLauncher(session) {
     }
     await abort();
   }
-  session.client.setHandler("abort", doAbort);
-  session.client.setHandler("switch", doSwitch);
+  session.client.rpcHandlerManager.registerHandler("abort", doAbort);
+  session.client.rpcHandlerManager.registerHandler("switch", doSwitch);
   const permissionHandler = new PermissionHandler(session);
   const messageQueue = new OutgoingMessageQueue(
     (logMessage) => session.client.sendClaudeSessionMessage(logMessage)
@@ -2807,265 +2803,6 @@ async function loop(opts) {
   }
 }
 
-function run(args, options) {
-  const RUNNER_PATH = resolve$1(join$1(projectPath(), "scripts", "ripgrep_launcher.cjs"));
-  return new Promise((resolve2, reject) => {
-    const child = spawn$1("node", [RUNNER_PATH, JSON.stringify(args)], {
-      stdio: ["pipe", "pipe", "pipe"],
-      cwd: options?.cwd
-    });
-    let stdout = "";
-    let stderr = "";
-    child.stdout.on("data", (data) => {
-      stdout += data.toString();
-    });
-    child.stderr.on("data", (data) => {
-      stderr += data.toString();
-    });
-    child.on("close", (code) => {
-      resolve2({
-        exitCode: code || 0,
-        stdout,
-        stderr
-      });
-    });
-    child.on("error", (err) => {
-      reject(err);
-    });
-  });
-}
-
-const execAsync = promisify(exec);
-function registerHandlers(session) {
-  session.setHandler("bash", async (data) => {
-    logger.debug("Shell command request:", data.command);
-    try {
-      const options = {
-        cwd: data.cwd,
-        timeout: data.timeout || 3e4
-        // Default 30 seconds timeout
-      };
-      const { stdout, stderr } = await execAsync(data.command, options);
-      return {
-        success: true,
-        stdout: stdout ? stdout.toString() : "",
-        stderr: stderr ? stderr.toString() : "",
-        exitCode: 0
-      };
-    } catch (error) {
-      const execError = error;
-      if (execError.code === "ETIMEDOUT" || execError.killed) {
-        return {
-          success: false,
-          stdout: execError.stdout || "",
-          stderr: execError.stderr || "",
-          exitCode: typeof execError.code === "number" ? execError.code : -1,
-          error: "Command timed out"
-        };
-      }
-      return {
-        success: false,
-        stdout: execError.stdout ? execError.stdout.toString() : "",
-        stderr: execError.stderr ? execError.stderr.toString() : execError.message || "Command failed",
-        exitCode: typeof execError.code === "number" ? execError.code : 1,
-        error: execError.message || "Command failed"
-      };
-    }
-  });
-  session.setHandler("readFile", async (data) => {
-    logger.debug("Read file request:", data.path);
-    try {
-      const buffer = await readFile$1(data.path);
-      const content = buffer.toString("base64");
-      return { success: true, content };
-    } catch (error) {
-      logger.debug("Failed to read file:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
-    }
-  });
-  session.setHandler("writeFile", async (data) => {
-    logger.debug("Write file request:", data.path);
-    try {
-      if (data.expectedHash !== null && data.expectedHash !== void 0) {
-        try {
-          const existingBuffer = await readFile$1(data.path);
-          const existingHash = createHash("sha256").update(existingBuffer).digest("hex");
-          if (existingHash !== data.expectedHash) {
-            return {
-              success: false,
-              error: `File hash mismatch. Expected: ${data.expectedHash}, Actual: ${existingHash}`
-            };
-          }
-        } catch (error) {
-          const nodeError = error;
-          if (nodeError.code !== "ENOENT") {
-            throw error;
-          }
-          return {
-            success: false,
-            error: "File does not exist but hash was provided"
-          };
-        }
-      } else {
-        try {
-          await stat(data.path);
-          return {
-            success: false,
-            error: "File already exists but was expected to be new"
-          };
-        } catch (error) {
-          const nodeError = error;
-          if (nodeError.code !== "ENOENT") {
-            throw error;
-          }
-        }
-      }
-      const buffer = Buffer.from(data.content, "base64");
-      await writeFile(data.path, buffer);
-      const hash = createHash("sha256").update(buffer).digest("hex");
-      return { success: true, hash };
-    } catch (error) {
-      logger.debug("Failed to write file:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
-    }
-  });
-  session.setHandler("listDirectory", async (data) => {
-    logger.debug("List directory request:", data.path);
-    try {
-      const entries = await readdir(data.path, { withFileTypes: true });
-      const directoryEntries = await Promise.all(
-        entries.map(async (entry) => {
-          const fullPath = join$1(data.path, entry.name);
-          let type = "other";
-          let size;
-          let modified;
-          if (entry.isDirectory()) {
-            type = "directory";
-          } else if (entry.isFile()) {
-            type = "file";
-          }
-          try {
-            const stats = await stat(fullPath);
-            size = stats.size;
-            modified = stats.mtime.getTime();
-          } catch (error) {
-            logger.debug(`Failed to stat ${fullPath}:`, error);
-          }
-          return {
-            name: entry.name,
-            type,
-            size,
-            modified
-          };
-        })
-      );
-      directoryEntries.sort((a, b) => {
-        if (a.type === "directory" && b.type !== "directory") return -1;
-        if (a.type !== "directory" && b.type === "directory") return 1;
-        return a.name.localeCompare(b.name);
-      });
-      return { success: true, entries: directoryEntries };
-    } catch (error) {
-      logger.debug("Failed to list directory:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
-    }
-  });
-  session.setHandler("getDirectoryTree", async (data) => {
-    logger.debug("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
-    async function buildTree(path, name, currentDepth) {
-      try {
-        const stats = await stat(path);
-        const node = {
-          name,
-          path,
-          type: stats.isDirectory() ? "directory" : "file",
-          size: stats.size,
-          modified: stats.mtime.getTime()
-        };
-        if (stats.isDirectory() && currentDepth < data.maxDepth) {
-          const entries = await readdir(path, { withFileTypes: true });
-          const children = [];
-          await Promise.all(
-            entries.map(async (entry) => {
-              if (entry.isSymbolicLink()) {
-                logger.debug(`Skipping symlink: ${join$1(path, entry.name)}`);
-                return;
-              }
-              const childPath = join$1(path, entry.name);
-              const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
-              if (childNode) {
-                children.push(childNode);
-              }
-            })
-          );
-          children.sort((a, b) => {
-            if (a.type === "directory" && b.type !== "directory") return -1;
-            if (a.type !== "directory" && b.type === "directory") return 1;
-            return a.name.localeCompare(b.name);
-          });
-          node.children = children;
-        }
-        return node;
-      } catch (error) {
-        logger.debug(`Failed to process ${path}:`, error instanceof Error ? error.message : String(error));
-        return null;
-      }
-    }
-    try {
-      if (data.maxDepth < 0) {
-        return { success: false, error: "maxDepth must be non-negative" };
-      }
-      const baseName = data.path === "/" ? "/" : data.path.split("/").pop() || data.path;
-      const tree = await buildTree(data.path, baseName, 0);
-      if (!tree) {
-        return { success: false, error: "Failed to access the specified path" };
-      }
-      return { success: true, tree };
-    } catch (error) {
-      logger.debug("Failed to get directory tree:", error);
-      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
-    }
-  });
-  session.setHandler("ripgrep", async (data) => {
-    logger.debug("Ripgrep request with args:", data.args, "cwd:", data.cwd);
-    try {
-      const result = await run(data.args, { cwd: data.cwd });
-      return {
-        success: true,
-        exitCode: result.exitCode,
-        stdout: result.stdout.toString(),
-        stderr: result.stderr.toString()
-      };
-    } catch (error) {
-      logger.debug("Failed to run ripgrep:", error);
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : "Failed to run ripgrep"
-      };
-    }
-  });
-  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"
-      };
-    }
-  });
-}
-
 class MessageQueue2 {
   queue = [];
   // Made public for testing
@@ -3599,7 +3336,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) {
@@ -3612,8 +3349,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;
@@ -3666,137 +3406,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 };
 }
 
@@ -3912,7 +3588,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) => {
@@ -4268,31 +3944,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);
@@ -4303,28 +4002,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");
@@ -4332,21 +4071,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);
@@ -4414,7 +4138,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();
@@ -4469,16 +4193,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}`);
@@ -4497,7 +4227,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 {
@@ -4525,7 +4258,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 = {
@@ -4553,17 +4289,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) => {
@@ -4620,7 +4366,7 @@ async function startDaemon() {
       startedAt: Date.now()
     };
     const api = new ApiClient(credentials.token, credentials.secret);
-    const machine = await api.createMachineOrGetExistingAsIs({
+    const machine = await api.getOrCreateMachine({
       machineId,
       metadata: initialMachineMetadata,
       daemonState: initialDaemonState
@@ -4802,6 +4548,17 @@ async function startHappyServer(client) {
   };
 }
 
+function registerKillSessionHandler(rpcHandlerManager, killThisHappy) {
+  rpcHandlerManager.registerHandler("killSession", async () => {
+    logger.debug("Kill session request received");
+    void killThisHappy();
+    return {
+      success: true,
+      message: "Killing happy-cli process"
+    };
+  });
+}
+
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = randomUUID();
@@ -4820,7 +4577,7 @@ async function start(credentials, options = {}) {
     process.exit(1);
   }
   logger.debug(`Using machineId: ${machineId}`);
-  await api.createMachineOrGetExistingAsIs({
+  await api.getOrCreateMachine({
     machineId,
     metadata: initialMachineMetadata
   });
@@ -4888,7 +4645,6 @@ async function start(credentials, options = {}) {
     allowedTools: mode.allowedTools,
     disallowedTools: mode.disallowedTools
   }));
-  registerHandlers(session);
   let currentPermissionMode = options.permissionMode;
   let currentModel = options.model;
   let currentFallbackModel = void 0;
@@ -5035,6 +4791,7 @@ async function start(credentials, options = {}) {
     logger.debug("[START] Unhandled rejection:", reason);
     cleanup();
   });
+  registerKillSessionHandler(session.rpcHandlerManager, cleanup);
   await loop({
     path: workingDirectory,
     model: options.model,
@@ -5050,7 +4807,7 @@ async function start(credentials, options = {}) {
         controlledByUser: newMode === "local"
       }));
     },
-    onSessionReady: (sessionInstance) => {
+    onSessionReady: (_sessionInstance) => {
     },
     mcpServers: {
       "happy": {
@@ -5392,33 +5149,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);
@@ -5448,6 +5733,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 {
@@ -5626,9 +5922,8 @@ ${chalk.bold("Happy supports ALL Claude options!")}
 ${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."));
@@ -5641,47 +5936,16 @@ ${chalk.bold.cyan("Claude Code Options (from `claude --help`):")}
     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);