happy-coder 0.3.1-beta.1 → 0.4.0

package/dist/index-QItBXhux.mjs

@@ -1,1540 +0,0 @@
-import chalk from 'chalk';
-import { l as logger, h as backoff, R as RawJSONLinesSchema, A as ApiClient, c as configuration, e as encodeBase64, j as encodeBase64Url, g as decodeBase64, k as delay, b as initializeConfiguration, i as initLoggerWithGlobalConfiguration } from './types-BRICSarm.mjs';
-import { randomUUID, randomBytes } from 'node:crypto';
-import { query, AbortError } from '@anthropic-ai/claude-code';
-import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
-import os, { homedir } from 'node:os';
-import { resolve, join, dirname } from 'node:path';
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import { fileURLToPath, URL as URL$1 } from 'node:url';
-import { watch as watch$1, readFile, mkdir, writeFile } from 'node:fs/promises';
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import { createServer, request as request$1 } from 'node:http';
-import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import * as z from 'zod';
-import { z as z$1 } from 'zod';
-import { request } from 'node:https';
-import net from 'node:net';
-import tweetnacl from 'tweetnacl';
-import axios from 'axios';
-import qrcode from 'qrcode-terminal';
-
-function formatClaudeMessage(message, onAssistantResult) {
-  logger.debugLargeJson("[CLAUDE] Message from non interactive & remote mode:", message);
-  switch (message.type) {
-    case "system": {
-      const sysMsg = message;
-      if (sysMsg.subtype === "init") {
-        console.log(chalk.gray("\u2500".repeat(60)));
-        console.log(chalk.blue.bold("\u{1F680} Session initialized:"), chalk.cyan(sysMsg.session_id));
-        console.log(chalk.gray(`  Model: ${sysMsg.model}`));
-        console.log(chalk.gray(`  CWD: ${sysMsg.cwd}`));
-        if (sysMsg.tools && sysMsg.tools.length > 0) {
-          console.log(chalk.gray(`  Tools: ${sysMsg.tools.join(", ")}`));
-        }
-        console.log(chalk.gray("\u2500".repeat(60)));
-      }
-      break;
-    }
-    case "user": {
-      const userMsg = message;
-      if (userMsg.message && typeof userMsg.message === "object" && "content" in userMsg.message) {
-        const content = userMsg.message.content;
-        if (typeof content === "string") {
-          console.log(chalk.magenta.bold("\n\u{1F464} User:"), content);
-        } else if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === "text") {
-              console.log(chalk.magenta.bold("\n\u{1F464} User:"), block.text);
-            } else if (block.type === "tool_result") {
-              console.log(chalk.green.bold("\n\u2705 Tool Result:"), chalk.gray(`(Tool ID: ${block.tool_use_id})`));
-              if (block.content) {
-                const outputStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content, null, 2);
-                const maxLength = 200;
-                if (outputStr.length > maxLength) {
-                  console.log(outputStr.substring(0, maxLength) + chalk.gray("\n... (truncated)"));
-                } else {
-                  console.log(outputStr);
-                }
-              }
-            }
-          }
-        } else {
-          console.log(chalk.magenta.bold("\n\u{1F464} User:"), JSON.stringify(content, null, 2));
-        }
-      }
-      break;
-    }
-    case "assistant": {
-      const assistantMsg = message;
-      if (assistantMsg.message && assistantMsg.message.content) {
-        console.log(chalk.cyan.bold("\n\u{1F916} Assistant:"));
-        for (const block of assistantMsg.message.content) {
-          if (block.type === "text") {
-            console.log(block.text);
-          } else if (block.type === "tool_use") {
-            console.log(chalk.yellow.bold(`
-\u{1F527} Tool: ${block.name}`));
-            if (block.input) {
-              const inputStr = JSON.stringify(block.input, null, 2);
-              const maxLength = 500;
-              if (inputStr.length > maxLength) {
-                console.log(chalk.gray("Input:"), inputStr.substring(0, maxLength) + chalk.gray("\n... (truncated)"));
-              } else {
-                console.log(chalk.gray("Input:"), inputStr);
-              }
-            }
-          }
-        }
-      }
-      break;
-    }
-    case "result": {
-      const resultMsg = message;
-      if (resultMsg.subtype === "success") {
-        if ("result" in resultMsg && resultMsg.result) {
-          console.log(chalk.green.bold("\n\u2728 Summary:"));
-          console.log(resultMsg.result);
-        }
-        if (resultMsg.usage) {
-          console.log(chalk.gray("\n\u{1F4CA} Session Stats:"));
-          console.log(chalk.gray(`  \u2022 Turns: ${resultMsg.num_turns}`));
-          console.log(chalk.gray(`  \u2022 Input tokens: ${resultMsg.usage.input_tokens}`));
-          console.log(chalk.gray(`  \u2022 Output tokens: ${resultMsg.usage.output_tokens}`));
-          if (resultMsg.usage.cache_read_input_tokens) {
-            console.log(chalk.gray(`  \u2022 Cache read tokens: ${resultMsg.usage.cache_read_input_tokens}`));
-          }
-          if (resultMsg.usage.cache_creation_input_tokens) {
-            console.log(chalk.gray(`  \u2022 Cache creation tokens: ${resultMsg.usage.cache_creation_input_tokens}`));
-          }
-          console.log(chalk.gray(`  \u2022 Cost: $${resultMsg.total_cost_usd.toFixed(4)}`));
-          console.log(chalk.gray(`  \u2022 Duration: ${resultMsg.duration_ms}ms`));
-          console.log(chalk.gray("\n\u{1F440} Back already?"));
-          console.log(chalk.green("\u{1F449} Press any key to continue your session in `claude`"));
-          if (onAssistantResult) {
-            Promise.resolve(onAssistantResult(resultMsg)).catch((err) => {
-              logger.debug("Error in onAssistantResult callback:", err);
-            });
-          }
-        }
-      } else if (resultMsg.subtype === "error_max_turns") {
-        console.log(chalk.red.bold("\n\u274C Error: Maximum turns reached"));
-        console.log(chalk.gray(`Completed ${resultMsg.num_turns} turns`));
-      } else if (resultMsg.subtype === "error_during_execution") {
-        console.log(chalk.red.bold("\n\u274C Error during execution"));
-        console.log(chalk.gray(`Completed ${resultMsg.num_turns} turns before error`));
-        logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
-      }
-      break;
-    }
-    default: {
-      const exhaustiveCheck = message;
-      if (process.env.DEBUG) {
-        console.log(chalk.gray(`[Unknown message type]`), exhaustiveCheck);
-      }
-    }
-  }
-}
-function printDivider() {
-  console.log(chalk.gray("\u2550".repeat(60)));
-}
-
-function claudeCheckSession(sessionId, path) {
-  const projectName = resolve(path).replace(/\//g, "-");
-  const projectDir = join(homedir(), ".claude", "projects", projectName);
-  const sessionFile = join(projectDir, `${sessionId}.jsonl`);
-  const sessionExists = existsSync(sessionFile);
-  if (!sessionExists) {
-    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
-    return false;
-  }
-  const sessionData = readFileSync(sessionFile, "utf-8").split("\n");
-  const hasGoodMessage = !!sessionData.find((v) => {
-    try {
-      return typeof JSON.parse(v).uuid === "string";
-    } catch (e) {
-      return false;
-    }
-  });
-  return hasGoodMessage;
-}
-
-async function claudeRemote(opts) {
-  let startFrom = opts.sessionId;
-  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
-    startFrom = null;
-  }
-  const abortController = new AbortController();
-  const sdkOptions = {
-    cwd: opts.path,
-    resume: startFrom ?? void 0,
-    mcpServers: opts.mcpServers,
-    permissionPromptToolName: opts.permissionPromptToolName,
-    executable: "node",
-    abortController
-  };
-  let aborted = false;
-  let response;
-  opts.abort.addEventListener("abort", () => {
-    if (!aborted) {
-      aborted = true;
-      if (response) {
-        (async () => {
-          try {
-            const r = await response.interrupt();
-          } catch (e) {
-          }
-          abortController.abort();
-        })();
-      } else {
-        abortController.abort();
-      }
-    }
-  });
-  logger.debug(`[claudeRemote] Starting query with messages`);
-  response = query({
-    prompt: opts.messages,
-    abortController,
-    options: sdkOptions
-  });
-  if (opts.interruptController) {
-    opts.interruptController.register(async () => {
-      logger.debug("[claudeRemote] Interrupting Claude via SDK");
-      await response.interrupt();
-    });
-  }
-  printDivider();
-  try {
-    logger.debug(`[claudeRemote] Starting to iterate over response`);
-    for await (const message of response) {
-      logger.debug(`[claudeRemote] Received message from SDK: ${message.type}`);
-      formatClaudeMessage(message, opts.onAssistantResult);
-      if (message.type === "system" && message.subtype === "init") {
-        const projectName = resolve(opts.path).replace(/\//g, "-");
-        const projectDir = join(homedir(), ".claude", "projects", projectName);
-        mkdirSync(projectDir, { recursive: true });
-        const watcher = watch(projectDir).on("change", (_, filename) => {
-          if (filename === `${message.session_id}.jsonl`) {
-            opts.onSessionFound(message.session_id);
-            watcher.close();
-          }
-        });
-      }
-    }
-    logger.debug(`[claudeRemote] Finished iterating over response`);
-  } catch (e) {
-    if (abortController.signal.aborted) {
-      logger.debug(`[claudeRemote] Aborted`);
-    }
-    if (e instanceof AbortError) {
-      logger.debug(`[claudeRemote] Aborted`);
-    } else {
-      throw e;
-    }
-  } finally {
-    if (opts.interruptController) {
-      opts.interruptController.unregister();
-    }
-  }
-  printDivider();
-  logger.debug(`[claudeRemote] Function completed`);
-}
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-async function claudeLocal(opts) {
-  const projectName = resolve(opts.path).replace(/\//g, "-");
-  const projectDir = join(homedir(), ".claude", "projects", projectName);
-  mkdirSync(projectDir, { recursive: true });
-  const watcher = watch(projectDir);
-  let resolvedSessionId = null;
-  const detectedIdsRandomUUID = /* @__PURE__ */ new Set();
-  const detectedIdsFileSystem = /* @__PURE__ */ new Set();
-  watcher.on("change", (event, filename) => {
-    if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
-      logger.debug("change", event, filename);
-      const sessionId = filename.replace(".jsonl", "");
-      if (detectedIdsFileSystem.has(sessionId)) {
-        return;
-      }
-      detectedIdsFileSystem.add(sessionId);
-      if (resolvedSessionId) {
-        return;
-      }
-      if (detectedIdsRandomUUID.has(sessionId)) {
-        resolvedSessionId = sessionId;
-        opts.onSessionFound(sessionId);
-      }
-    }
-  });
-  let startFrom = opts.sessionId;
-  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
-    startFrom = null;
-  }
-  try {
-    process.stdin.pause();
-    await new Promise((r, reject) => {
-      const args = [];
-      if (startFrom) {
-        args.push("--resume", startFrom);
-      }
-      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || resolve(join(__dirname, "..", "scripts", "claudeInteractiveLaunch.cjs"));
-      const child = spawn("node", [claudeCliPath, ...args], {
-        stdio: ["inherit", "inherit", "inherit", "pipe"],
-        signal: opts.abort,
-        cwd: opts.path
-      });
-      if (child.stdio[3]) {
-        const rl = createInterface({
-          input: child.stdio[3],
-          crlfDelay: Infinity
-        });
-        rl.on("line", (line) => {
-          const sessionMatch = line.match(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i);
-          if (sessionMatch) {
-            detectedIdsRandomUUID.add(sessionMatch[0]);
-            if (resolvedSessionId) {
-              return;
-            }
-            if (detectedIdsFileSystem.has(sessionMatch[0])) {
-              resolvedSessionId = sessionMatch[0];
-              opts.onSessionFound(sessionMatch[0]);
-            }
-          }
-        });
-        rl.on("error", (err) => {
-          console.error("Error reading from fd 3:", err);
-        });
-      }
-      child.on("error", (error) => {
-      });
-      child.on("exit", (code, signal) => {
-        if (signal === "SIGTERM" && opts.abort.aborted) {
-          r();
-        } else if (signal) {
-          reject(new Error(`Process terminated with signal: ${signal}`));
-        } else {
-          r();
-        }
-      });
-    });
-  } finally {
-    watcher.close();
-    process.stdin.resume();
-  }
-  return resolvedSessionId;
-}
-
-class MessageQueue {
-  queue = [];
-  waiters = [];
-  closed = false;
-  closePromise;
-  closeResolve;
-  constructor() {
-    this.closePromise = new Promise((resolve) => {
-      this.closeResolve = resolve;
-    });
-  }
-  /**
-   * Push a message to the queue
-   */
-  push(message) {
-    if (this.closed) {
-      throw new Error("Cannot push to closed queue");
-    }
-    logger.debug(`[MessageQueue] push() called. Waiters: ${this.waiters.length}, Queue size before: ${this.queue.length}`);
-    const waiter = this.waiters.shift();
-    if (waiter) {
-      logger.debug(`[MessageQueue] Found waiter! Delivering message directly: "${message}"`);
-      waiter({
-        type: "user",
-        message: {
-          role: "user",
-          content: message
-        },
-        parent_tool_use_id: null,
-        session_id: ""
-      });
-    } else {
-      logger.debug(`[MessageQueue] No waiter found. Adding to queue: "${message}"`);
-      this.queue.push({
-        type: "user",
-        message: {
-          role: "user",
-          content: message
-        },
-        parent_tool_use_id: null,
-        session_id: ""
-      });
-    }
-    logger.debug(`[MessageQueue] push() completed. Waiters: ${this.waiters.length}, Queue size after: ${this.queue.length}`);
-  }
-  /**
-   * Close the queue - no more messages can be pushed
-   */
-  close() {
-    logger.debug(`[MessageQueue] close() called. Waiters: ${this.waiters.length}`);
-    this.closed = true;
-    this.closeResolve?.();
-  }
-  /**
-   * Check if the queue is closed
-   */
-  isClosed() {
-    return this.closed;
-  }
-  /**
-   * Get the current queue size
-   */
-  size() {
-    return this.queue.length;
-  }
-  /**
-   * Async iterator implementation
-   */
-  async *[Symbol.asyncIterator]() {
-    logger.debug(`[MessageQueue] Iterator started`);
-    while (true) {
-      const message = this.queue.shift();
-      if (message !== void 0) {
-        logger.debug(`[MessageQueue] Iterator yielding queued message`);
-        yield message;
-        continue;
-      }
-      if (this.closed) {
-        logger.debug(`[MessageQueue] Iterator ending - queue closed`);
-        return;
-      }
-      logger.debug(`[MessageQueue] Iterator waiting for next message...`);
-      const nextMessage = await this.waitForNext();
-      if (nextMessage === void 0) {
-        logger.debug(`[MessageQueue] Iterator ending - no more messages`);
-        return;
-      }
-      logger.debug(`[MessageQueue] Iterator yielding waited message`);
-      yield nextMessage;
-    }
-  }
-  /**
-   * Wait for the next message or queue closure
-   */
-  waitForNext() {
-    return new Promise((resolve) => {
-      if (this.closed) {
-        logger.debug(`[MessageQueue] waitForNext() called but queue is closed`);
-        resolve(void 0);
-        return;
-      }
-      const waiter = (value) => resolve(value);
-      this.waiters.push(waiter);
-      logger.debug(`[MessageQueue] waitForNext() adding waiter. Total waiters: ${this.waiters.length}`);
-      this.closePromise?.then(() => {
-        const index = this.waiters.indexOf(waiter);
-        if (index !== -1) {
-          this.waiters.splice(index, 1);
-          logger.debug(`[MessageQueue] waitForNext() waiter removed due to close. Remaining waiters: ${this.waiters.length}`);
-          resolve(void 0);
-        }
-      });
-    });
-  }
-}
-
-class InvalidateSync {
-  _invalidated = false;
-  _invalidatedDouble = false;
-  _stopped = false;
-  _command;
-  _pendings = [];
-  constructor(command) {
-    this._command = command;
-  }
-  invalidate() {
-    if (this._stopped) {
-      return;
-    }
-    if (!this._invalidated) {
-      this._invalidated = true;
-      this._invalidatedDouble = false;
-      this._doSync();
-    } else {
-      if (!this._invalidatedDouble) {
-        this._invalidatedDouble = true;
-      }
-    }
-  }
-  async invalidateAndAwait() {
-    if (this._stopped) {
-      return;
-    }
-    await new Promise((resolve) => {
-      this._pendings.push(resolve);
-      this.invalidate();
-    });
-  }
-  stop() {
-    if (this._stopped) {
-      return;
-    }
-    this._notifyPendings();
-    this._stopped = true;
-  }
-  _notifyPendings = () => {
-    for (let pending of this._pendings) {
-      pending();
-    }
-    this._pendings = [];
-  };
-  _doSync = async () => {
-    await backoff(async () => {
-      if (this._stopped) {
-        return;
-      }
-      await this._command();
-    });
-    if (this._stopped) {
-      this._notifyPendings();
-      return;
-    }
-    if (this._invalidatedDouble) {
-      this._invalidatedDouble = false;
-      this._doSync();
-    } else {
-      this._invalidated = false;
-      this._notifyPendings();
-    }
-  };
-}
-
-function createSessionScanner(opts) {
-  const projectName = resolve(opts.workingDirectory).replace(/\//g, "-");
-  const projectDir = join(homedir(), ".claude", "projects", projectName);
-  let finishedSessions = /* @__PURE__ */ new Set();
-  let pendingSessions = /* @__PURE__ */ new Set();
-  let currentSessionId = null;
-  let currentSessionWatcherAbortController = null;
-  let processedMessages = /* @__PURE__ */ new Set();
-  let seenRemoteUserMessageCounters = /* @__PURE__ */ new Map();
-  const sync = new InvalidateSync(async () => {
-    let sessions = [];
-    for (let p of pendingSessions) {
-      sessions.push(p);
-    }
-    if (currentSessionId) {
-      sessions.push(currentSessionId);
-    }
-    let processSessionFile = async (sessionId) => {
-      const expectedSessionFile = join(projectDir, `${sessionId}.jsonl`);
-      let file;
-      try {
-        file = await readFile(expectedSessionFile, "utf-8");
-      } catch (error) {
-        return;
-      }
-      let lines = file.split("\n");
-      for (let l of lines) {
-        try {
-          let message = JSON.parse(l);
-          let parsed = RawJSONLinesSchema.safeParse(message);
-          if (!parsed.success) {
-            logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
-            continue;
-          }
-          let key = getMessageKey(parsed.data);
-          if (processedMessages.has(key)) {
-            continue;
-          }
-          processedMessages.add(key);
-          logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
-          logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
-          if (parsed.data.type === "user" && typeof parsed.data.message.content === "string") {
-            const currentCounter = seenRemoteUserMessageCounters.get(parsed.data.message.content);
-            if (currentCounter && currentCounter > 0) {
-              seenRemoteUserMessageCounters.set(parsed.data.message.content, currentCounter - 1);
-              continue;
-            }
-          }
-          opts.onMessage(parsed.data);
-        } catch (e) {
-          continue;
-        }
-      }
-    };
-    for (let session of sessions) {
-      await processSessionFile(session);
-    }
-    for (let p of sessions) {
-      if (pendingSessions.has(p)) {
-        pendingSessions.delete(p);
-        finishedSessions.add(p);
-      }
-    }
-    currentSessionWatcherAbortController?.abort();
-    currentSessionWatcherAbortController = new AbortController();
-    void (async () => {
-      if (currentSessionId) {
-        const sessionFile = join(projectDir, `${currentSessionId}.jsonl`);
-        try {
-          for await (const change of watch$1(sessionFile, { persistent: true, signal: currentSessionWatcherAbortController.signal })) {
-            await processSessionFile(currentSessionId);
-          }
-        } catch (error) {
-          if (error.name !== "AbortError") {
-            logger.debug(`[SESSION_SCANNER] Watch error: ${error.message}`);
-          }
-        }
-      }
-    })();
-  });
-  const intervalId = setInterval(() => {
-    sync.invalidate();
-  }, 3e3);
-  return {
-    refresh: () => sync.invalidate(),
-    cleanup: () => {
-      clearInterval(intervalId);
-      currentSessionWatcherAbortController?.abort();
-    },
-    onNewSession: (sessionId) => {
-      if (currentSessionId === sessionId) {
-        return;
-      }
-      if (finishedSessions.has(sessionId)) {
-        return;
-      }
-      if (pendingSessions.has(sessionId)) {
-        return;
-      }
-      if (currentSessionId) {
-        pendingSessions.add(currentSessionId);
-      }
-      logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
-      currentSessionId = sessionId;
-      sync.invalidate();
-    },
-    onRemoteUserMessageForDeduplication: (messageContent) => {
-      seenRemoteUserMessageCounters.set(messageContent, (seenRemoteUserMessageCounters.get(messageContent) || 0) + 1);
-    }
-  };
-}
-function getMessageKey(message) {
-  if (message.type === "user") {
-    return `user:${message.uuid}`;
-  } else if (message.type === "assistant") {
-    const { usage, ...messageWithoutUsage } = message.message;
-    return stableStringify(messageWithoutUsage);
-  } else if (message.type === "summary") {
-    return `summary:${message.leafUuid}`;
-  } else if (message.type === "system") {
-    return `system:${message.uuid}`;
-  }
-  return `unknown:<error, this should be unreachable>`;
-}
-function stableStringify(obj) {
-  return JSON.stringify(sortKeys(obj), null, 2);
-}
-function sortKeys(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortKeys);
-  } else if (value && typeof value === "object" && value.constructor === Object) {
-    return Object.keys(value).sort().reduce((result, key) => {
-      result[key] = sortKeys(value[key]);
-      return result;
-    }, {});
-  } else {
-    return value;
-  }
-}
-
-async function loop(opts) {
-  let mode = opts.startingMode ?? "interactive";
-  let currentMessageQueue = new MessageQueue();
-  let sessionId = null;
-  let onMessage = null;
-  const sessionScanner = createSessionScanner({
-    workingDirectory: opts.path,
-    onMessage: (message) => {
-      opts.session.sendClaudeSessionMessage(message);
-    }
-  });
-  opts.session.onUserMessage((message) => {
-    sessionScanner.onRemoteUserMessageForDeduplication(message.content.text);
-    currentMessageQueue.push(message.content.text);
-    logger.debugLargeJson("User message pushed to queue:", message);
-    if (onMessage) {
-      onMessage();
-    }
-  });
-  let onSessionFound = (newSessionId) => {
-    sessionId = newSessionId;
-    sessionScanner.onNewSession(newSessionId);
-  };
-  while (true) {
-    if (currentMessageQueue.size() > 0) {
-      mode = "remote";
-      continue;
-    }
-    if (mode === "interactive") {
-      let abortedOutside = false;
-      const interactiveAbortController = new AbortController();
-      opts.session.setHandler("switch", () => {
-        if (!interactiveAbortController.signal.aborted) {
-          abortedOutside = true;
-          mode = "remote";
-          interactiveAbortController.abort();
-        }
-      });
-      onMessage = () => {
-        if (!interactiveAbortController.signal.aborted) {
-          abortedOutside = true;
-          mode = "remote";
-          interactiveAbortController.abort();
-        }
-        onMessage = null;
-      };
-      await claudeLocal({
-        path: opts.path,
-        sessionId,
-        onSessionFound,
-        abort: interactiveAbortController.signal
-      });
-      onMessage = null;
-      if (!abortedOutside) {
-        return;
-      }
-      if (mode !== "interactive") {
-        console.log("Switching to remote mode...");
-      }
-    }
-    if (mode === "remote") {
-      logger.debug("Starting " + sessionId);
-      const remoteAbortController = new AbortController();
-      opts.session.setHandler("abort", () => {
-        if (!remoteAbortController.signal.aborted) {
-          remoteAbortController.abort();
-        }
-      });
-      const abortHandler = () => {
-        if (!remoteAbortController.signal.aborted) {
-          mode = "interactive";
-          remoteAbortController.abort();
-        }
-        if (process.stdin.isTTY) {
-          process.stdin.setRawMode(false);
-        }
-      };
-      process.stdin.resume();
-      if (process.stdin.isTTY) {
-        process.stdin.setRawMode(true);
-      }
-      process.stdin.setEncoding("utf8");
-      process.stdin.on("data", abortHandler);
-      try {
-        logger.debug(`Starting claudeRemote with messages: ${currentMessageQueue.size()}`);
-        await claudeRemote({
-          abort: remoteAbortController.signal,
-          sessionId,
-          path: opts.path,
-          mcpServers: opts.mcpServers,
-          permissionPromptToolName: opts.permissionPromptToolName,
-          onSessionFound,
-          messages: currentMessageQueue,
-          onAssistantResult: opts.onAssistantResult,
-          interruptController: opts.interruptController
-        });
-      } finally {
-        process.stdin.off("data", abortHandler);
-        if (process.stdin.isTTY) {
-          process.stdin.setRawMode(false);
-        }
-        currentMessageQueue.close();
-        currentMessageQueue = new MessageQueue();
-      }
-      if (mode !== "remote") {
-        console.log("Switching back to good old claude...");
-      }
-    }
-  }
-}
-
-async function startPermissionServerV2(handler) {
-  const mcp = new McpServer({
-    name: "Permission Server",
-    version: "1.0.0",
-    description: "A server that allows you to request permissions from the user"
-  });
-  mcp.registerTool("ask_permission", {
-    description: "Request permission to execute a tool",
-    title: "Request Permission",
-    inputSchema: {
-      tool_name: z$1.string().describe("The tool that needs permission"),
-      input: z$1.any().describe("The arguments for the tool")
-    }
-    // outputSchema: {
-    //     approved: z.boolean().describe('Whether the tool was approved'),
-    //     reason: z.string().describe('The reason for the approval or denial'),
-    // },
-  }, async (args) => {
-    const response = await handler({ name: args.tool_name, arguments: args.input });
-    const result = response.approved ? { behavior: "allow", updatedInput: args.input || {} } : { behavior: "deny", message: response.reason || "Permission denied by user" };
-    return {
-      content: [
-        {
-          type: "text",
-          text: JSON.stringify(result)
-        }
-      ],
-      isError: false
-    };
-  });
-  const transport = new StreamableHTTPServerTransport({
-    // NOTE: Returning session id here will result in claude
-    // sdk spawn to fail with `Invalid Request: Server already initialized`
-    sessionIdGenerator: void 0
-  });
-  await mcp.connect(transport);
-  const server = createServer(async (req, res) => {
-    try {
-      await transport.handleRequest(req, res);
-    } catch (error) {
-      logger.debug("Error handling request:", error);
-      if (!res.headersSent) {
-        res.writeHead(500).end();
-      }
-    }
-  });
-  const baseUrl = await new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      resolve(new URL(`http://127.0.0.1:${addr.port}`));
-    });
-  });
-  return {
-    url: baseUrl.toString(),
-    toolName: "ask_permission"
-  };
-}
-
-class InterruptController {
-  interruptFn;
-  isInterrupting = false;
-  /**
-   * Register an interrupt function from claudeRemote
-   */
-  register(fn) {
-    this.interruptFn = fn;
-  }
-  /**
-   * Unregister the interrupt function (cleanup)
-   */
-  unregister() {
-    this.interruptFn = void 0;
-    this.isInterrupting = false;
-  }
-  /**
-   * Trigger the interrupt - can be called from anywhere
-   */
-  async interrupt() {
-    if (!this.interruptFn || this.isInterrupting) {
-      return false;
-    }
-    this.isInterrupting = true;
-    try {
-      await this.interruptFn();
-      return true;
-    } catch (error) {
-      logger.debug("Failed to interrupt Claude:", error);
-      return false;
-    } finally {
-      this.isInterrupting = false;
-    }
-  }
-  /**
-   * Check if interrupt is available
-   */
-  canInterrupt() {
-    return !!this.interruptFn && !this.isInterrupting;
-  }
-}
-
-var version = "0.1.9";
-var packageJson = {
-	version: version};
-
-async function startAnthropicActivityProxy(onClaudeActivity) {
-  const requestTimeouts = /* @__PURE__ */ new Map();
-  let requestCounter = 0;
-  let idleTimer = null;
-  const maxTimeBeforeIdle = 50;
-  const requestTimeout = 5 * 60 * 1e3;
-  const cleanupRequest = (requestId, reason) => {
-    const timeout = requestTimeouts.get(requestId);
-    if (timeout) {
-      clearTimeout(timeout);
-      requestTimeouts.delete(requestId);
-      logger.debug(`[AnthropicProxy #${requestId}] Cleaned up (${reason}), active requests: ${requestTimeouts.size}`);
-      claudeDidSomeWork();
-    }
-  };
-  const claudeDidSomeWork = () => {
-    if (idleTimer) clearTimeout(idleTimer);
-    if (requestTimeouts.size === 0) {
-      idleTimer = setTimeout(() => {
-        logger.debug(`[AnthropicProxy] Idle for ${maxTimeBeforeIdle}ms, active requests: ${requestTimeouts.size}`);
-        onClaudeActivity("idle");
-      }, maxTimeBeforeIdle);
-    }
-  };
-  const server = createServer((req, res) => {
-    const requestId = ++requestCounter;
-    const isAnthropicRequest = req.headers.host === "api.anthropic.com" || req.url?.includes("anthropic.com");
-    if (isAnthropicRequest) {
-      const timeout = setTimeout(() => {
-        logger.debug(`[AnthropicProxy #${requestId}] Request timeout after ${requestTimeout}ms`);
-        cleanupRequest(requestId, "timeout");
-      }, requestTimeout);
-      requestTimeouts.set(requestId, timeout);
-      onClaudeActivity("working");
-      logger.debug(`[AnthropicProxy #${requestId}] Anthropic request: ${req.method} ${req.url}, active requests: ${requestTimeouts.size}`);
-    }
-    const chunks = [];
-    req.on("data", (chunk) => {
-      chunks.push(chunk);
-      if (isAnthropicRequest) {
-        claudeDidSomeWork();
-      }
-    });
-    req.on("end", () => {
-      const body = Buffer.concat(chunks);
-      let targetUrl;
-      if (isAnthropicRequest) {
-        targetUrl = new URL$1(req.url || "/", "https://api.anthropic.com");
-      } else {
-        const protocol = req.headers["x-forwarded-proto"] || "https";
-        const host = req.headers.host || "localhost";
-        targetUrl = new URL$1(req.url || "/", `${protocol}://${host}`);
-      }
-      const options = {
-        hostname: targetUrl.hostname,
-        port: targetUrl.port || (targetUrl.protocol === "https:" ? 443 : 80),
-        path: targetUrl.pathname + targetUrl.search,
-        method: req.method,
-        headers: {
-          ...req.headers,
-          host: targetUrl.hostname
-        }
-      };
-      const requestMethod = targetUrl.protocol === "https:" ? request : request$1;
-      const proxyReq = requestMethod(options, (proxyRes) => {
-        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
-        proxyRes.pipe(res);
-        proxyRes.on("end", () => {
-          if (isAnthropicRequest) {
-            cleanupRequest(requestId, "completed");
-          }
-        });
-      });
-      proxyReq.on("error", (error) => {
-        if (isAnthropicRequest) {
-          cleanupRequest(requestId, `error: ${error.message}`);
-        } else {
-          logger.debug(`[AnthropicProxy #${requestId}] Error:`, error.message);
-        }
-        res.writeHead(502);
-        res.end("Bad Gateway");
-      });
-      if (body.length > 0) {
-        proxyReq.write(body);
-      }
-      proxyReq.end();
-    });
-  });
-  server.on("connect", (req, clientSocket, head) => {
-    const requestId = ++requestCounter;
-    const [hostname, port] = req.url?.split(":") || ["", "443"];
-    const isAnthropicRequest = hostname === "api.anthropic.com";
-    if (isAnthropicRequest) {
-      const timeout = setTimeout(() => {
-        logger.debug(`[AnthropicProxy #${requestId}] CONNECT timeout after ${requestTimeout}ms`);
-        cleanupRequest(requestId, "timeout");
-      }, requestTimeout);
-      requestTimeouts.set(requestId, timeout);
-      onClaudeActivity("working");
-      logger.debug(`[AnthropicProxy #${requestId}] CONNECT to api.anthropic.com, active requests: ${requestTimeouts.size}`);
-    }
-    const serverSocket = net.connect(parseInt(port) || 443, hostname, () => {
-      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
-      serverSocket.write(head);
-      serverSocket.pipe(clientSocket);
-      clientSocket.pipe(serverSocket);
-    });
-    const cleanup = () => {
-      if (isAnthropicRequest) {
-        cleanupRequest(requestId, "CONNECT closed");
-      }
-    };
-    serverSocket.on("error", (err) => {
-      logger.debug(`[AnthropicProxy #${requestId}] CONNECT error:`, err.message);
-      clientSocket.end();
-      cleanup();
-    });
-    clientSocket.on("error", cleanup);
-    clientSocket.on("end", cleanup);
-    serverSocket.on("end", cleanup);
-  });
-  const url = await new Promise((resolve) => {
-    server.listen(0, "127.0.0.1", () => {
-      const addr = server.address();
-      if (addr && typeof addr === "object") {
-        resolve(`http://127.0.0.1:${addr.port}`);
-      }
-    });
-  });
-  logger.debug(`[AnthropicProxy] Started at ${url}`);
-  return {
-    url,
-    cleanup: () => {
-      if (idleTimer) clearTimeout(idleTimer);
-      for (const [requestId, timeout] of requestTimeouts) {
-        clearTimeout(timeout);
-        logger.debug(`[AnthropicProxy] Cleaning up timeout for request #${requestId}`);
-      }
-      requestTimeouts.clear();
-      if (requestTimeouts.size > 0) {
-        logger.debug(`[AnthropicProxy] Warning: ${requestTimeouts.size} active requests still pending at cleanup:`, Array.from(requestTimeouts.keys()));
-      }
-      server.close();
-    }
-  };
-}
-
-async function start(credentials, options = {}) {
-  const workingDirectory = process.cwd();
-  const sessionTag = randomUUID();
-  const api = new ApiClient(credentials.token, credentials.secret);
-  let state = {};
-  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version };
-  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
-  logger.debug(`Session created: ${response.id}`);
-  const session = api.session(response);
-  const pushClient = api.push();
-  let thinking = false;
-  let pingInterval = setInterval(() => {
-    session.keepAlive(thinking);
-  }, 2e3);
-  const antropicActivityProxy = await startAnthropicActivityProxy(
-    (activity) => {
-      const newThinking = activity === "working";
-      if (newThinking !== thinking) {
-        thinking = newThinking;
-        logger.debug(`[PING] Thinking state changed: ${thinking}`);
-        session.keepAlive(thinking);
-      }
-    }
-  );
-  process.env.HTTP_PROXY = antropicActivityProxy.url;
-  process.env.HTTPS_PROXY = antropicActivityProxy.url;
-  logger.debug(`[AnthropicProxy] Set HTTP_PROXY and HTTPS_PROXY to ${antropicActivityProxy.url}`);
-  const logPath = await logger.logFilePathPromise;
-  logger.info(`Session: ${response.id}`);
-  logger.infoDeveloper(`Logs: ${logPath}`);
-  const interruptController = new InterruptController();
-  let requests = /* @__PURE__ */ new Map();
-  const permissionServer = await startPermissionServerV2(async (request) => {
-    const id = randomUUID();
-    let promise = new Promise((resolve) => {
-      requests.set(id, resolve);
-    });
-    let timeout = setTimeout(async () => {
-      logger.info("Permission timeout - attempting to interrupt Claude");
-      const interrupted = await interruptController.interrupt();
-      if (interrupted) {
-        logger.info("Claude interrupted successfully");
-      }
-      requests.delete(id);
-      session.updateAgentState((currentState) => {
-        let r = { ...currentState.requests };
-        delete r[id];
-        return {
-          ...currentState,
-          requests: r
-        };
-      });
-    }, 1e3 * 60 * 4.5);
-    logger.info("Permission request" + id + " " + JSON.stringify(request));
-    try {
-      await pushClient.sendToAllDevices(
-        "Permission Request",
-        `Claude wants to use ${request.name}`,
-        {
-          sessionId: response.id,
-          requestId: id,
-          tool: request.name,
-          type: "permission_request"
-        }
-      );
-      logger.info("Push notification sent for permission request");
-    } catch (error) {
-      logger.debug("Failed to send push notification:", error);
-    }
-    session.updateAgentState((currentState) => ({
-      ...currentState,
-      requests: {
-        ...currentState.requests,
-        [id]: {
-          tool: request.name,
-          arguments: request.arguments
-        }
-      }
-    }));
-    promise.then(() => clearTimeout(timeout)).catch(() => clearTimeout(timeout));
-    return promise;
-  });
-  session.setHandler("permission", async (message) => {
-    logger.info("Permission response" + JSON.stringify(message));
-    const id = message.id;
-    const resolve = requests.get(id);
-    if (resolve) {
-      if (!message.approved) {
-        logger.debug("Permission denied, interrupting Claude");
-        await interruptController.interrupt();
-      }
-      resolve({ approved: message.approved, reason: message.reason });
-    } else {
-      logger.info("Permission request stale, likely timed out");
-      return;
-    }
-    session.updateAgentState((currentState) => {
-      let r = { ...currentState.requests };
-      delete r[id];
-      return {
-        ...currentState,
-        requests: r
-      };
-    });
-  });
-  session.setHandler("abort", async () => {
-    logger.info("Abort request - interrupting Claude");
-    await interruptController.interrupt();
-  });
-  const onAssistantResult = async (result) => {
-    try {
-      const summary = "result" in result && result.result ? result.result.substring(0, 100) + (result.result.length > 100 ? "..." : "") : "";
-      await pushClient.sendToAllDevices(
-        "Your move :D",
-        summary,
-        {
-          sessionId: response.id,
-          type: "assistant_result",
-          turns: result.num_turns,
-          duration_ms: result.duration_ms,
-          cost_usd: result.total_cost_usd
-        }
-      );
-      logger.debug("Push notification sent: Assistant result");
-    } catch (error) {
-      logger.debug("Failed to send assistant result push notification:", error);
-    }
-  };
-  await loop({
-    path: workingDirectory,
-    model: options.model,
-    permissionMode: options.permissionMode,
-    startingMode: options.startingMode,
-    mcpServers: {
-      "permission": {
-        type: "http",
-        url: permissionServer.url
-      }
-    },
-    permissionPromptToolName: "mcp__permission__" + permissionServer.toolName,
-    session,
-    onAssistantResult,
-    interruptController
-  });
-  clearInterval(pingInterval);
-  if (antropicActivityProxy) {
-    logger.info("[AnthropicProxy] Shutting down activity monitoring proxy");
-    antropicActivityProxy.cleanup();
-  }
-  process.exit(0);
-}
-
-const defaultSettings = {
-  onboardingCompleted: false
-};
-async function readSettings() {
-  if (!existsSync(configuration.settingsFile)) {
-    return { ...defaultSettings };
-  }
-  try {
-    const content = await readFile(configuration.settingsFile, "utf8");
-    return JSON.parse(content);
-  } catch {
-    return { ...defaultSettings };
-  }
-}
-async function writeSettings(settings) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
-  }
-  await writeFile(configuration.settingsFile, JSON.stringify(settings, null, 2));
-}
-const credentialsSchema = z.object({
-  secret: z.string().base64(),
-  token: z.string()
-});
-async function readCredentials() {
-  if (!existsSync(configuration.privateKeyFile)) {
-    return null;
-  }
-  try {
-    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
-    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
-    return {
-      secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
-      token: credentials.token
-    };
-  } catch {
-    return null;
-  }
-}
-async function writeCredentials(credentials) {
-  if (!existsSync(configuration.happyDir)) {
-    await mkdir(configuration.happyDir, { recursive: true });
-  }
-  await writeFile(configuration.privateKeyFile, JSON.stringify({
-    secret: encodeBase64(credentials.secret),
-    token: credentials.token
-  }, null, 2));
-}
-
-function displayQRCode(url) {
-  console.log("=".repeat(80));
-  console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
-  console.log("=".repeat(80));
-  qrcode.generate(url, { small: true }, (qr) => {
-    for (let l of qr.split("\n")) {
-      console.log(" ".repeat(10) + l);
-    }
-  });
-  console.log("=".repeat(80));
-}
-
-async function doAuth() {
-  console.log("Starting authentication...");
-  const secret = new Uint8Array(randomBytes(32));
-  const keypair = tweetnacl.box.keyPair.fromSecretKey(secret);
-  try {
-    await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
-      publicKey: encodeBase64(keypair.publicKey)
-    });
-  } catch (error) {
-    console.log("Failed to create authentication request, please try again later.");
-    return null;
-  }
-  console.log("Please, authenticate using mobile app");
-  const authUrl = "happy://terminal?" + encodeBase64Url(keypair.publicKey);
-  displayQRCode(authUrl);
-  if (process.env.DEBUG === "1") {
-    console.log("\n\u{1F4CB} For manual entry, copy this URL:");
-    console.log(authUrl);
-  }
-  let credentials = null;
-  while (true) {
-    try {
-      const response = await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
-        publicKey: encodeBase64(keypair.publicKey)
-      });
-      if (response.data.state === "authorized") {
-        let token = response.data.token;
-        let r = decodeBase64(response.data.response);
-        let decrypted = decryptWithEphemeralKey(r, keypair.secretKey);
-        if (decrypted) {
-          credentials = {
-            secret: decrypted,
-            token
-          };
-          await writeCredentials(credentials);
-          return credentials;
-        } else {
-          console.log("Failed to decrypt response, please try again later.");
-          return null;
-        }
-      }
-    } catch (error) {
-      console.log("Failed to create authentication request, please try again later.");
-      return null;
-    }
-    await delay(1e3);
-  }
-  return null;
-}
-function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
-  const ephemeralPublicKey = encryptedBundle.slice(0, 32);
-  const nonce = encryptedBundle.slice(32, 32 + tweetnacl.box.nonceLength);
-  const encrypted = encryptedBundle.slice(32 + tweetnacl.box.nonceLength);
-  const decrypted = tweetnacl.box.open(encrypted, nonce, ephemeralPublicKey, recipientSecretKey);
-  if (!decrypted) {
-    return null;
-  }
-  return decrypted;
-}
-
-(async () => {
-  const args = process.argv.slice(2);
-  let installationLocation = args.includes("--local") || process.env.HANDY_LOCAL ? "local" : "global";
-  initializeConfiguration(installationLocation);
-  initLoggerWithGlobalConfiguration();
-  logger.debug("Starting happy CLI with args: ", process.argv);
-  const subcommand = args[0];
-  if (subcommand === "logout") {
-    try {
-      await cleanKey();
-    } catch (error) {
-      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-      if (process.env.DEBUG) {
-        console.error(error);
-      }
-      process.exit(1);
-    }
-    return;
-  } else if (subcommand === "daemon") {
-    if (process.env.HAPPY_DAEMON_MODE) {
-      const { run } = await import('./run-DMbKhYfb.mjs');
-      await run();
-    } else {
-      const daemonSubcommand = args[1];
-      if (daemonSubcommand === "install") {
-        const { install } = await import('./install-B0DnBGS_.mjs');
-        try {
-          await install();
-        } catch (error) {
-          console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-          process.exit(1);
-        }
-      } else if (daemonSubcommand === "uninstall") {
-        const { uninstall } = await import('./uninstall-BGgl5V8F.mjs');
-        try {
-          await uninstall();
-        } catch (error) {
-          console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-          process.exit(1);
-        }
-      } else {
-        console.log(`
-${chalk.bold("happy daemon")} - Daemon management
-
-${chalk.bold("Usage:")}
-  sudo happy daemon install     Install the daemon (requires sudo)
-  sudo happy daemon uninstall   Uninstall the daemon (requires sudo)
-
-${chalk.bold("Note:")} The daemon runs in the background and provides persistent services.
-Currently only supported on macOS.
-`);
-      }
-    }
-    return;
-  } else {
-    const options = {};
-    let showHelp = false;
-    let showVersion = false;
-    let forceAuth = false;
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg === "-h" || arg === "--help") {
-        showHelp = true;
-      } else if (arg === "-v" || arg === "--version") {
-        showVersion = true;
-      } else if (arg === "--auth" || arg === "--login") {
-        forceAuth = true;
-      } else if (arg === "-m" || arg === "--model") {
-        options.model = args[++i];
-      } else if (arg === "-p" || arg === "--permission-mode") {
-        options.permissionMode = z$1.enum(["auto", "default", "plan"]).parse(args[++i]);
-      } else if (arg === "--local") {
-        i++;
-      } else if (arg === "--happy-starting-mode") {
-        options.startingMode = z$1.enum(["interactive", "remote"]).parse(args[++i]);
-      } else if (arg === "--happy-daemon") {
-        process.env.HAPPY_DAEMON_MODE = "true";
-        const { run } = await import('./run-DMbKhYfb.mjs');
-        await run();
-        return;
-      } else if (arg === "--happy-daemon-start") {
-        const { spawn } = await import('child_process');
-        const { isDaemonRunning } = await import('./run-DMbKhYfb.mjs');
-        if (isDaemonRunning()) {
-          console.log("Happy daemon is already running");
-          return;
-        }
-        const happyPath = process.argv[1];
-        const daemonProcess = spawn("node", [happyPath, "--happy-daemon"], {
-          detached: true,
-          stdio: "ignore",
-          env: process.env
-        });
-        daemonProcess.unref();
-        console.log("Happy daemon started");
-        return;
-      } else if (arg === "--happy-daemon-stop") {
-        const { isDaemonRunning } = await import('./run-DMbKhYfb.mjs');
-        const pidFile = join(homedir(), ".happy", "daemon-pid");
-        if (!existsSync(pidFile)) {
-          console.log("Happy daemon is not running");
-          return;
-        }
-        try {
-          const pid = parseInt(await readFile(pidFile, "utf-8"));
-          process.kill(pid, "SIGTERM");
-          console.log("Happy daemon stopped");
-        } catch (error) {
-          console.error("Failed to stop daemon:", error);
-        }
-        return;
-      } else if (arg === "--happy-daemon-install") {
-        const { install } = await import('./install-DEPy62QN.mjs');
-        await install();
-        return;
-      } else if (arg === "--happy-daemon-uninstall") {
-        const { uninstall } = await import('./uninstall-BWHglipH.mjs');
-        await uninstall();
-        return;
-      } else {
-        console.error(chalk.red(`Unknown argument: ${arg}`));
-        process.exit(1);
-      }
-    }
-    if (showHelp) {
-      console.log(`
-${chalk.bold("happy")} - Claude Code session sharing
-
-${chalk.bold("Usage:")}
-  happy [options]
-  happy logout     Logs out of your account and removes data directory
-  happy daemon     Manage the background daemon (macOS only)
-
-${chalk.bold("Options:")}
-  -h, --help              Show this help message
-  -v, --version           Show version
-  -m, --model <model>     Claude model to use (default: sonnet)
-  -p, --permission-mode   Permission mode: auto, default, or plan
-  --auth, --login         Force re-authentication
-
-  [Daemon Management]
-  --happy-daemon-start    Start the daemon in background
-  --happy-daemon-stop     Stop the daemon
-  --happy-daemon-install  Install daemon to run on startup
-  --happy-daemon-uninstall  Uninstall daemon from startup
-
-  [Advanced]
-  --local < global | local >
-      Will use .happy folder in the current directory for storing your private key and debug logs. 
-      You will require re-login each time you run this in a new directory.
-  --happy-starting-mode <interactive|remote>
-      Set the starting mode for new sessions (default: remote)
-
-${chalk.bold("Examples:")}
-  happy                   Start a session with default settings
-  happy -m opus           Use Claude Opus model
-  happy -p plan           Use plan permission mode
-  happy --auth            Force re-authentication before starting session
-  happy logout            Logs out of your account and removes data directory
-`);
-      process.exit(0);
-    }
-    if (showVersion) {
-      console.log(packageJson.version);
-      process.exit(0);
-    }
-    let credentials = await readCredentials();
-    if (!credentials || forceAuth) {
-      let res = await doAuth();
-      if (!res) {
-        process.exit(1);
-      }
-      credentials = res;
-    }
-    const settings = await readSettings() || { onboardingCompleted: false };
-    if (settings.daemonInstalled === void 0 && process.platform === "darwin") {
-      console.log(chalk.cyan("\n\u{1F680} Happy Daemon Setup\n"));
-      console.log("The Happy daemon runs in the background to enable faster session startup");
-      console.log("and remote control from the mobile app.\n");
-      const rl = createInterface({
-        input: process.stdin,
-        output: process.stdout
-      });
-      const answer = await new Promise((resolve) => {
-        rl.question(chalk.green("Would you like to install the daemon to run on startup? (recommended) [Y/n]: "), resolve);
-      });
-      rl.close();
-      const shouldInstall = answer.toLowerCase() !== "n";
-      if (shouldInstall) {
-        try {
-          const { install } = await import('./install-DEPy62QN.mjs');
-          await install();
-          settings.daemonInstalled = true;
-          const { isDaemonRunning } = await import('./run-DMbKhYfb.mjs');
-          if (!isDaemonRunning()) {
-            const { spawn } = await import('child_process');
-            const happyPath = process.argv[1];
-            const daemonProcess = spawn("node", [happyPath, "--happy-daemon"], {
-              detached: true,
-              stdio: "ignore",
-              env: process.env
-            });
-            daemonProcess.unref();
-          }
-          console.log(chalk.green("\u2713 Daemon installed and started"));
-        } catch (error) {
-          console.error(chalk.red("Failed to install daemon:"), error);
-          console.log(chalk.yellow("You can install the daemon later with: sudo happy daemon install"));
-        }
-      } else {
-        settings.daemonInstalled = false;
-        console.log(chalk.yellow("You can install the daemon later with: sudo happy daemon install"));
-      }
-      await writeSettings(settings);
-    }
-    try {
-      await start(credentials, options);
-    } catch (error) {
-      console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
-      if (process.env.DEBUG) {
-        console.error(error);
-      }
-      process.exit(1);
-    }
-  }
-})();
-async function cleanKey() {
-  const happyDir = configuration.happyDir;
-  if (!existsSync(happyDir)) {
-    console.log(chalk.yellow("No happy data directory found at:"), happyDir);
-    return;
-  }
-  console.log(chalk.blue("Found happy data directory at:"), happyDir);
-  console.log(chalk.yellow("\u26A0\uFE0F  This will remove all authentication data and require reconnecting your phone."));
-  const rl = createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-  const answer = await new Promise((resolve) => {
-    rl.question(chalk.yellow("Are you sure you want to remove the happy data directory? (y/N): "), resolve);
-  });
-  rl.close();
-  if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
-    try {
-      rmSync(happyDir, { recursive: true, force: true });
-      console.log(chalk.green("\u2713 Happy data directory removed successfully"));
-      console.log(chalk.blue("\u2139\uFE0F  You will need to reconnect your phone on the next session"));
-    } catch (error) {
-      throw new Error(`Failed to remove data directory: ${error instanceof Error ? error.message : "Unknown error"}`);
-    }
-  } else {
-    console.log(chalk.blue("Operation cancelled"));
-  }
-}
-
-export { readCredentials as a, doAuth as d, readSettings as r, writeSettings as w };