happy-coder 0.1.1 → 0.1.3

package/dist/index.mjs

@@ -1,17 +1,21 @@
 import axios from 'axios';
 import * as fs from 'node:fs';
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
-import { chmod } from 'node:fs/promises';
+import { existsSync, rmSync } from 'node:fs';
+import { mkdir, readFile, writeFile, watch, readdir, open } from 'node:fs/promises';
 import { randomBytes, randomUUID } from 'node:crypto';
 import tweetnacl from 'tweetnacl';
-import { homedir } from 'node:os';
-import { join, basename } from 'node:path';
+import os, { homedir } from 'node:os';
+import { join, resolve, basename } from 'node:path';
 import chalk from 'chalk';
+import { appendFileSync } from 'fs';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
 import { z } from 'zod';
 import qrcode from 'qrcode-terminal';
-import { spawn } from 'node:child_process';
+import { query } from '@anthropic-ai/claude-code';
+import * as pty from 'node-pty';
+import { createInterface } from 'node:readline';
+import { createServer } from 'node:http';
 
 function encodeBase64(buffer) {
   return Buffer.from(buffer).toString("base64");
@@ -53,19 +57,6 @@ function authChallenge(secret) {
   };
 }
 
-async function getOrCreateSecretKey() {
-  const keyPath = join(homedir(), ".handy", "access.key");
-  if (existsSync(keyPath)) {
-    const keyBase642 = readFileSync(keyPath, "utf8").trim();
-    return new Uint8Array(Buffer.from(keyBase642, "base64"));
-  }
-  const secret = getRandomBytes(32);
-  const keyBase64 = encodeBase64(secret);
-  mkdirSync(join(homedir(), ".handy"), { recursive: true });
-  writeFileSync(keyPath, keyBase64);
-  await chmod(keyPath, 384);
-  return secret;
-}
 async function authGetToken(secret) {
   const { challenge, publicKey, signature } = authChallenge(secret);
   const response = await axios.post(`https://handy-api.korshakov.org/v1/auth`, {
@@ -83,46 +74,143 @@ function generateAppUrl(secret) {
   return `handy://${secretBase64Url}`;
 }
 
+const handyDir = join(homedir(), ".handy");
+const logsDir = join(handyDir, "logs");
+const settingsFile = join(handyDir, "settings.json");
+const privateKeyFile = join(handyDir, "access.key");
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!existsSync(settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await readFile(settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
+}
+async function writeSettings(settings) {
+  if (!existsSync(handyDir)) {
+    await mkdir(handyDir, { recursive: true });
+  }
+  await writeFile(settingsFile, JSON.stringify(settings, null, 2));
+}
+async function readPrivateKey() {
+  if (!existsSync(privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = (await readFile(privateKeyFile, "utf8")).trim();
+    return new Uint8Array(Buffer.from(keyBase64, "base64"));
+  } catch {
+    return null;
+  }
+}
+async function writePrivateKey(key) {
+  if (!existsSync(handyDir)) {
+    await mkdir(handyDir, { recursive: true });
+  }
+  const keyBase64 = Buffer.from(key).toString("base64");
+  await writeFile(privateKeyFile, keyBase64, "utf8");
+}
+async function getSessionLogPath() {
+  if (!existsSync(logsDir)) {
+    await mkdir(logsDir, { recursive: true });
+  }
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toLocaleString("sv-SE", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).replace(/[: ]/g, "-").replace(/,/g, "");
+  return join(logsDir, `${timestamp}.log`);
+}
+
 class Logger {
+  constructor(logFilePathPromise = getSessionLogPath()) {
+    this.logFilePathPromise = logFilePathPromise;
+  }
   debug(message, ...args) {
-    if (process.env.DEBUG) {
-      this.log("DEBUG" /* DEBUG */, message, ...args);
-    }
+    this.logToFile(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, message, ...args);
   }
-  error(message, ...args) {
-    this.log("ERROR" /* ERROR */, message, ...args);
+  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
+    if (!process.env.DEBUG) {
+      this.debug(`In production, skipping message inspection`);
+    }
+    const truncateStrings = (obj) => {
+      if (typeof obj === "string") {
+        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
+      }
+      if (Array.isArray(obj)) {
+        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
+        if (obj.length > maxArrayLength) {
+          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
+        }
+        return truncatedArray;
+      }
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          result[key] = truncateStrings(value);
+        }
+        return result;
+      }
+      return obj;
+    };
+    const truncatedObject = truncateStrings(object);
+    const json = JSON.stringify(truncatedObject, null, 2);
+    this.logToFile(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, message, "\n", json);
   }
   info(message, ...args) {
-    this.log("INFO" /* INFO */, message, ...args);
-  }
-  warn(message, ...args) {
-    this.log("WARN" /* WARN */, message, ...args);
-  }
-  getTimestamp() {
-    return (/* @__PURE__ */ new Date()).toISOString();
+    this.logToConsole("info", "", message, ...args);
   }
-  log(level, message, ...args) {
-    const timestamp = this.getTimestamp();
-    const prefix = `[${timestamp}] [${level}]`;
+  logToConsole(level, prefix, message, ...args) {
     switch (level) {
-      case "DEBUG" /* DEBUG */: {
+      case "debug": {
         console.log(chalk.gray(prefix), message, ...args);
         break;
       }
-      case "ERROR" /* ERROR */: {
+      case "error": {
         console.error(chalk.red(prefix), message, ...args);
         break;
       }
-      case "INFO" /* INFO */: {
+      case "info": {
         console.log(chalk.blue(prefix), message, ...args);
         break;
       }
-      case "WARN" /* WARN */: {
+      case "warn": {
         console.log(chalk.yellow(prefix), message, ...args);
         break;
       }
+      default: {
+        this.debug("Unknown log level:", level);
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
     }
   }
+  logToFile(prefix, message, ...args) {
+    const logLine = `${prefix} ${message} ${args.map(
+      (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
+    ).join(" ")}
+`;
+    this.logFilePathPromise.then((logFilePath) => {
+      appendFileSync(logFilePath, logLine);
+    }).catch((error) => {
+      if (process.env.DEBUG) {
+        console.log("This message only visible in DEBUG mode, not in production");
+        console.error("Failed to resolve log file path:", error);
+        console.log(prefix, message, ...args);
+      }
+    });
+  }
 }
 const logger = new Logger();
 
@@ -141,17 +229,33 @@ const UpdateBodySchema = z.object({
   // Session ID
   t: z.literal("new-message")
 });
+const UpdateSessionBodySchema = z.object({
+  t: z.literal("update-session"),
+  sid: z.string(),
+  metadata: z.object({
+    version: z.number(),
+    metadata: z.string()
+  }).nullish(),
+  agentState: z.object({
+    version: z.number(),
+    agentState: z.string()
+  }).nullish()
+});
 z.object({
   id: z.string(),
   seq: z.number(),
-  body: UpdateBodySchema,
+  body: z.union([UpdateBodySchema, UpdateSessionBodySchema]),
   createdAt: z.number()
 });
 z.object({
   createdAt: z.number(),
   id: z.string(),
   seq: z.number(),
-  updatedAt: z.number()
+  updatedAt: z.number(),
+  metadata: z.any(),
+  metadataVersion: z.number(),
+  agentState: z.any().nullable(),
+  agentStateVersion: z.number()
 });
 z.object({
   content: SessionMessageContentSchema,
@@ -166,7 +270,11 @@ z.object({
     tag: z.string(),
     seq: z.number(),
     createdAt: z.number(),
-    updatedAt: z.number()
+    updatedAt: z.number(),
+    metadata: z.string(),
+    metadataVersion: z.number(),
+    agentState: z.string().nullable(),
+    agentStateVersion: z.number()
   })
 });
 const UserMessageSchema = z.object({
@@ -174,7 +282,11 @@ const UserMessageSchema = z.object({
   content: z.object({
     type: z.literal("text"),
     text: z.string()
-  })
+  }),
+  localKey: z.string().optional(),
+  // Mobile messages include this
+  sentFrom: z.enum(["mobile", "cli"]).optional()
+  // Source identifier
 });
 const AgentMessageSchema = z.object({
   role: z.literal("agent"),
@@ -182,19 +294,57 @@ const AgentMessageSchema = z.object({
 });
 z.union([UserMessageSchema, AgentMessageSchema]);
 
+async function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.max(currentFailureCount, maxFailureCount);
+  return Math.round(Math.random() * maxDelayRet);
+}
+function createBackoff(opts) {
+  return async (callback) => {
+    let currentFailureCount = 0;
+    const minDelay = 250;
+    const maxDelay = 1e3;
+    const maxFailureCount = 50;
+    while (true) {
+      try {
+        return await callback();
+      } catch (e) {
+        if (currentFailureCount < maxFailureCount) {
+          currentFailureCount++;
+        }
+        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+        await delay(waitForRequest);
+      }
+    }
+  };
+}
+let backoff = createBackoff();
+
 class ApiSessionClient extends EventEmitter {
   token;
   secret;
   sessionId;
+  metadata;
+  metadataVersion;
+  agentState;
+  agentStateVersion;
   socket;
   receivedMessages = /* @__PURE__ */ new Set();
+  sentLocalKeys = /* @__PURE__ */ new Set();
   pendingMessages = [];
   pendingMessageCallback = null;
-  constructor(token, secret, sessionId) {
+  rpcHandlers = /* @__PURE__ */ new Map();
+  constructor(token, secret, session) {
     super();
     this.token = token;
     this.secret = secret;
-    this.sessionId = sessionId;
+    this.sessionId = session.id;
+    this.metadata = session.metadata;
+    this.metadataVersion = session.metadataVersion;
+    this.agentState = session.agentState;
+    this.agentStateVersion = session.agentStateVersion;
     this.socket = io("https://handy-api.korshakov.org", {
       auth: {
         token: this.token
@@ -210,26 +360,64 @@ class ApiSessionClient extends EventEmitter {
     });
     this.socket.on("connect", () => {
       logger.info("Socket connected successfully");
+      this.reregisterHandlers();
+    });
+    this.socket.on("rpc-request", async (data, callback) => {
+      try {
+        const method = data.method;
+        const handler = this.rpcHandlers.get(method);
+        if (!handler) {
+          logger.debug("[SOCKET] [RPC] [ERROR] method not found", { method });
+          const errorResponse = { error: "Method not found" };
+          const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+          callback(encryptedError);
+          return;
+        }
+        const decryptedParams = decrypt(decodeBase64(data.params), this.secret);
+        const result = await handler(decryptedParams);
+        const encryptedResponse = encodeBase64(encrypt(result, this.secret));
+        callback(encryptedResponse);
+      } catch (error) {
+        logger.debug("[SOCKET] [RPC] [ERROR] Error handling RPC request", { error });
+        const errorResponse = { error: error instanceof Error ? error.message : "Unknown error" };
+        const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+        callback(encryptedError);
+      }
     });
     this.socket.on("disconnect", (reason) => {
-      logger.warn("Socket disconnected:", reason);
+      logger.debug("[API] Socket disconnected:", reason);
     });
     this.socket.on("connect_error", (error) => {
-      logger.error("Socket connection error:", error.message);
+      logger.debug("[API] Socket connection error:", error.message);
     });
     this.socket.on("update", (data) => {
       if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
         const body = decrypt(decodeBase64(data.body.message.content.c), this.secret);
-        const result = UserMessageSchema.safeParse(body);
-        if (result.success) {
-          if (!this.receivedMessages.has(data.body.message.id)) {
+        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+        const userResult = UserMessageSchema.safeParse(body);
+        if (userResult.success) {
+          const localKey = body.localKey;
+          if (localKey && this.sentLocalKeys.has(localKey)) {
+            logger.debug(`[SOCKET] Ignoring echo of our own message with localKey: ${localKey}`);
+          } else if (!this.receivedMessages.has(data.body.message.id)) {
             this.receivedMessages.add(data.body.message.id);
             if (this.pendingMessageCallback) {
-              this.pendingMessageCallback(result.data);
+              this.pendingMessageCallback(userResult.data);
             } else {
-              this.pendingMessages.push(result.data);
+              this.pendingMessages.push(userResult.data);
             }
           }
+        } else {
+          this.emit("message", body);
+        }
+      } else if (data.body.t === "update-session") {
+        if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
+          this.metadata = decrypt(decodeBase64(data.body.metadata.metadata), this.secret);
+          this.metadataVersion = data.body.metadata.version;
+        }
+        if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+          this.agentState = data.body.agentState.agentState ? decrypt(decodeBase64(data.body.agentState.agentState), this.secret) : null;
+          this.agentStateVersion = data.body.agentState.version;
         }
       }
     });
@@ -243,19 +431,120 @@ class ApiSessionClient extends EventEmitter {
   }
   /**
    * Send message to session
-   * @param body - Message body
+   * @param body - Message body (can be MessageContent or raw content for agent messages)
    */
   sendMessage(body) {
-    let content = {
-      role: "agent",
-      content: body
-    };
+    logger.debugLargeJson("[SOCKET] Sending message through socket:", body);
+    let content;
+    if (body.role === "user" || body.role === "agent") {
+      content = body;
+      if (body.role === "user" && body.localKey) {
+        this.sentLocalKeys.add(body.localKey);
+        logger.debug(`[SOCKET] Tracking sent localKey: ${body.localKey}`);
+      }
+    } else {
+      content = {
+        role: "agent",
+        content: body
+      };
+    }
     const encrypted = encodeBase64(encrypt(content, this.secret));
     this.socket.emit("message", {
       sid: this.sessionId,
       message: encrypted
     });
   }
+  /**
+   * Send a ping message to keep the connection alive
+   */
+  keepAlive(thinking) {
+    this.socket.volatile.emit("session-alive", { sid: this.sessionId, time: Date.now(), thinking });
+  }
+  /**
+   * Send session death message
+   */
+  sendSessionDeath() {
+    this.socket.emit("session-end", { sid: this.sessionId, time: Date.now() });
+  }
+  /**
+   * Update session metadata
+   * @param handler - Handler function that returns the updated metadata
+   */
+  updateMetadata(handler) {
+    backoff(async () => {
+      let updated = handler(this.metadata);
+      const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: encodeBase64(encrypt(updated, this.secret)) });
+      if (answer.result === "success") {
+        this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        this.metadataVersion = answer.version;
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.metadataVersion) {
+          this.metadataVersion = answer.version;
+          this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        }
+        throw new Error("Metadata version mismatch");
+      } else if (answer.result === "error") ;
+    });
+  }
+  /**
+   * Update session agent state
+   * @param handler - Handler function that returns the updated agent state
+   */
+  updateAgentState(handler) {
+    backoff(async () => {
+      let updated = handler(this.agentState || {});
+      const answer = await this.socket.emitWithAck("update-agent", { sid: this.sessionId, expectedVersion: this.agentStateVersion, agentState: updated ? encodeBase64(encrypt(updated, this.secret)) : null });
+      if (answer.result === "success") {
+        this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
+        this.agentStateVersion = answer.version;
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.agentStateVersion) {
+          this.agentStateVersion = answer.version;
+          this.agentState = answer.agentState ? decrypt(decodeBase64(answer.agentState), this.secret) : null;
+        }
+        throw new Error("Agent state version mismatch");
+      } else if (answer.result === "error") ;
+    });
+  }
+  /**
+   * Add a custom RPC handler for a specific method with encrypted arguments and responses
+   * @param method - The method name to handle
+   * @param handler - The handler function to call when the method is invoked
+   */
+  addHandler(method, handler) {
+    const prefixedMethod = `${this.sessionId}:${method}`;
+    this.rpcHandlers.set(prefixedMethod, handler);
+    this.socket.emit("rpc-register", { method: prefixedMethod });
+    logger.debug("Registered RPC handler", { method, prefixedMethod });
+  }
+  /**
+   * Re-register all RPC handlers after reconnection
+   */
+  reregisterHandlers() {
+    logger.debug("Re-registering RPC handlers after reconnection", {
+      totalMethods: this.rpcHandlers.size
+    });
+    for (const [prefixedMethod] of this.rpcHandlers) {
+      this.socket.emit("rpc-register", { method: prefixedMethod });
+      logger.debug("Re-registered method", { prefixedMethod });
+    }
+  }
+  /**
+   * Wait for socket buffer to flush
+   */
+  async flush() {
+    if (!this.socket.connected) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.socket.emit("ping", () => {
+        resolve();
+      });
+      setTimeout(() => {
+        resolve();
+      }, 1e4);
+    });
+  }
   async close() {
     this.socket.close();
   }
@@ -271,11 +560,15 @@ class ApiClient {
   /**
    * Create a new session or load existing one with the given tag
    */
-  async getOrCreateSession(tag) {
+  async getOrCreateSession(opts) {
     try {
       const response = await axios.post(
         `https://handy-api.korshakov.org/v1/sessions`,
-        { tag },
+        {
+          tag: opts.tag,
+          metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
+          agentState: opts.state ? encodeBase64(encrypt(opts.state, this.secret)) : null
+        },
         {
           headers: {
             "Authorization": `Bearer ${this.token}`,
@@ -283,10 +576,21 @@ class ApiClient {
           }
         }
       );
-      logger.info(`Session created/loaded: ${response.data.session.id} (tag: ${tag})`);
-      return response.data;
+      logger.info(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      let raw = response.data.session;
+      let session = {
+        id: raw.id,
+        createdAt: raw.createdAt,
+        updatedAt: raw.updatedAt,
+        seq: raw.seq,
+        metadata: decrypt(decodeBase64(raw.metadata), this.secret),
+        metadataVersion: raw.metadataVersion,
+        agentState: raw.agentState ? decrypt(decodeBase64(raw.agentState), this.secret) : null,
+        agentStateVersion: raw.agentStateVersion
+      };
+      return session;
     } catch (error) {
-      logger.error("Failed to get or create session:", error);
+      logger.debug("[API] [ERROR] Failed to get or create session:", error);
       throw new Error(`Failed to get or create session: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -295,27 +599,82 @@ class ApiClient {
    * @param id - Session ID
    * @returns Session client
    */
-  session(id) {
-    return new ApiSessionClient(this.token, this.secret, id);
+  session(session) {
+    return new ApiSessionClient(this.token, this.secret, session);
   }
 }
 
 function displayQRCode(url) {
+  logger.info("=".repeat(50));
+  logger.info("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
+  logger.info("=".repeat(50));
+  qrcode.generate(url, { small: true }, (qr) => {
+    for (let l of qr.split("\n")) {
+      logger.info("         " + l);
+    }
+  });
+  logger.info(`\u{1F4CB} Or use this URL: ${url}`);
+}
+
+async function* claude(options) {
   try {
-    logger.info("=".repeat(50));
-    logger.info("\u{1F4F1} Scan this QR code with your mobile device:");
-    logger.info("=".repeat(50));
-    qrcode.generate(url, { small: true }, (qr) => {
-      for (let l of qr.split("\n")) {
-        logger.info("         " + l);
-      }
+    logger.debug("[CLAUDE SDK] Starting SDK with options:", options);
+    const sdkOptions = {
+      cwd: options.workingDirectory,
+      model: options.model,
+      permissionMode: mapPermissionMode(options.permissionMode),
+      resume: options.sessionId,
+      // Add MCP servers if provided
+      mcpServers: options.mcpServers,
+      // Add permission prompt tool name if provided
+      permissionPromptToolName: options.permissionPromptToolName
+    };
+    const response = query({
+      prompt: options.command,
+      abortController: options.abort,
+      options: sdkOptions
     });
-    logger.info("=".repeat(50));
+    for await (const message of response) {
+      logger.debugLargeJson("[CLAUDE SDK] Message:", message);
+      switch (message.type) {
+        case "system":
+          if (message.subtype === "init") {
+            yield { type: "json", data: message };
+          }
+          break;
+        case "assistant":
+          yield { type: "json", data: message };
+          break;
+        case "user":
+          break;
+        case "result":
+          if (message.is_error) {
+            yield { type: "error", error: `Claude execution error: ${message.subtype}` };
+            yield { type: "exit", code: 1, signal: null };
+          } else {
+            yield { type: "json", data: message };
+            yield { type: "exit", code: 0, signal: null };
+          }
+          break;
+        default:
+          yield { type: "json", data: message };
+      }
+    }
   } catch (error) {
-    logger.error("Failed to generate QR code:", error);
-    logger.info(`\u{1F4CB} Use this URL to connect: ${url}`);
+    logger.debug("[CLAUDE SDK] [ERROR] SDK error:", error);
+    yield { type: "error", error: error instanceof Error ? error.message : String(error) };
+    yield { type: "exit", code: 1, signal: null };
   }
 }
+function mapPermissionMode(mode) {
+  if (!mode) return void 0;
+  const modeMap = {
+    "auto": "acceptEdits",
+    "default": "default",
+    "plan": "bypassPermissions"
+  };
+  return modeMap[mode];
+}
 
 function claudePath() {
   if (fs.existsSync(process.env.HOME + "/.claude/local/claude")) {
@@ -325,237 +684,775 @@ function claudePath() {
   }
 }
 
-async function* claude(options) {
-  const args = buildArgs(options);
-  const path = claudePath();
-  logger.info("Spawning Claude CLI with args:", args);
-  const process = spawn(path, args, {
+function spawnInteractiveClaude(options) {
+  const args = [];
+  if (options.sessionId) {
+    args.push("--resume", options.sessionId);
+  }
+  if (options.model) {
+    args.push("-m", options.model);
+  }
+  if (options.permissionMode) {
+    args.push("-p", options.permissionMode);
+  }
+  logger.debug("[PTY] Creating PTY process with args:", args);
+  const ptyProcess = pty.spawn(claudePath(), args, {
+    name: "xterm-256color",
+    cols: process.stdout.columns,
+    rows: process.stdout.rows,
     cwd: options.workingDirectory,
-    stdio: ["pipe", "pipe", "pipe"],
-    shell: false
+    env: process.env
   });
-  process.stdin?.end();
-  let outputBuffer = "";
-  let stderrBuffer = "";
-  let processExited = false;
-  const outputQueue = [];
-  let outputResolve = null;
-  process.stdout?.on("data", (data) => {
-    outputBuffer += data.toString();
-    const lines = outputBuffer.split("\n");
-    outputBuffer = lines.pop() || "";
-    for (const line of lines) {
-      if (line.trim()) {
-        try {
-          const json = JSON.parse(line);
-          outputQueue.push({ type: "json", data: json });
-        } catch {
-          outputQueue.push({ type: "text", data: line });
-        }
-        if (outputResolve) {
-          outputResolve();
-          outputResolve = null;
-        }
-      }
-    }
-  });
-  process.stderr?.on("data", (data) => {
-    stderrBuffer += data.toString();
-    const lines = stderrBuffer.split("\n");
-    stderrBuffer = lines.pop() || "";
-    for (const line of lines) {
-      if (line.trim()) {
-        outputQueue.push({ type: "error", error: line });
-        if (outputResolve) {
-          outputResolve();
-          outputResolve = null;
-        }
-      }
-    }
+  logger.debug("[PTY] PTY process created, pid:", ptyProcess.pid);
+  ptyProcess.onData((data) => {
+    process.stdout.write(data);
   });
-  process.on("exit", (code, signal) => {
-    processExited = true;
-    outputQueue.push({ type: "exit", code, signal });
-    if (outputResolve) {
-      outputResolve();
-      outputResolve = null;
-    }
+  const resizeHandler = () => {
+    logger.debug("[PTY] SIGWINCH received, resizing to:", { cols: process.stdout.columns, rows: process.stdout.rows });
+    ptyProcess.resize(process.stdout.columns, process.stdout.rows);
+  };
+  process.on("SIGWINCH", resizeHandler);
+  const exitPromise = new Promise((resolve) => {
+    ptyProcess.onExit((exitCode) => {
+      logger.debug("[PTY] PTY process exited with code:", exitCode.exitCode);
+      logger.debug("[PTY] Removing SIGWINCH handler");
+      process.removeListener("SIGWINCH", resizeHandler);
+      resolve(exitCode.exitCode);
+    });
   });
-  process.on("error", (error) => {
-    outputQueue.push({ type: "error", error: error.message });
-    processExited = true;
-    if (outputResolve) {
-      outputResolve();
-      outputResolve = null;
+  return {
+    write: (data) => {
+      ptyProcess.write(data);
+    },
+    kill: () => {
+      logger.debug("[PTY] Kill called");
+      process.removeListener("SIGWINCH", resizeHandler);
+      ptyProcess.kill();
+    },
+    waitForExit: () => exitPromise,
+    resize: (cols, rows) => {
+      logger.debug("[PTY] Manual resize called:", { cols, rows });
+      ptyProcess.resize(cols, rows);
     }
-  });
-  while (!processExited || outputQueue.length > 0) {
-    if (outputQueue.length === 0) {
-      await new Promise((resolve) => {
-        outputResolve = resolve;
-        if (outputQueue.length > 0 || processExited) {
-          resolve();
-          outputResolve = null;
-        }
-      });
+  };
+}
+
+const PersisstedMessageSchema = z.object({
+  sessionId: z.string(),
+  type: z.string(),
+  subtype: z.string().optional()
+}).loose();
+const SDKMessageSchema = z.object({
+  session_id: z.string().optional(),
+  type: z.string(),
+  subtype: z.string().optional()
+}).loose();
+function parseClaudePersistedMessage(message) {
+  const result = PersisstedMessageSchema.safeParse(message);
+  if (!result.success) {
+    logger.debug("[ERROR] Failed to parse interactive message:", result.error);
+    logger.debugLargeJson("[ERROR] Message:", message);
+    return void 0;
+  }
+  return {
+    sessionId: result.data.sessionId,
+    type: result.data.type,
+    rawMessage: {
+      ...message,
+      // Lets patch the message with another type of id just in case
+      session_id: result.data.sessionId
     }
-    while (outputQueue.length > 0) {
-      const output = outputQueue.shift();
-      yield output;
+  };
+}
+function parseClaudeSdkMessage(message) {
+  const result = SDKMessageSchema.safeParse(message);
+  if (!result.success) {
+    logger.debug("[ERROR] Failed to parse SDK message:", result.error);
+    return void 0;
+  }
+  return {
+    sessionId: result.data.session_id,
+    type: result.data.type,
+    rawMessage: {
+      ...message,
+      // Lets patch the message with another type of id just in case
+      session_id: result.data.session_id
     }
+  };
+}
+
+async function* watchMostRecentSession(workingDirectory, abortController) {
+  const projectName = resolve(workingDirectory).replace(/\//g, "-");
+  const projectDir = join(homedir(), ".claude", "projects", projectName);
+  logger.debug(`Starting session watcher for project: ${projectName}`);
+  logger.debug(`Watching directory: ${projectDir}`);
+  if (!existsSync(projectDir)) {
+    logger.debug("Project directory does not exist, creating it");
+    await mkdir(projectDir, { recursive: true });
   }
-  if (outputBuffer.trim()) {
+  const getSessionFiles = async () => {
+    const files = await readdir(projectDir);
+    return files.filter((f) => f.endsWith(".jsonl")).map((f) => ({
+      name: f,
+      path: join(projectDir, f),
+      sessionId: f.replace(".jsonl", "")
+    }));
+  };
+  const initialFiles = await getSessionFiles();
+  const knownFiles = new Set(initialFiles.map((f) => f.name));
+  logger.debug(`Found ${knownFiles.size} existing session files`);
+  logger.debug("Starting directory watcher for new session files");
+  const dirWatcher = watch(projectDir, { signal: abortController.signal });
+  const newSessionFilePath = await (async () => {
+    logger.debug("Entering directory watcher loop");
     try {
-      const json = JSON.parse(outputBuffer);
-      yield { type: "json", data: json };
-    } catch {
-      yield { type: "text", data: outputBuffer };
+      for await (const event of dirWatcher) {
+        logger.debug(`Directory watcher event: ${event.eventType} - ${event.filename}`);
+        if (event.filename && event.filename.endsWith(".jsonl")) {
+          const files = await getSessionFiles();
+          for (const file of files) {
+            if (!knownFiles.has(file.name)) {
+              logger.debug(`New session file detected: ${file.name}`);
+              knownFiles.add(file.name);
+              logger.debug(`Returning file path: ${file.path}`);
+              return file.path;
+            }
+          }
+        }
+      }
+    } catch (err) {
+      if (err.name !== "AbortError") {
+        logger.debug("[ERROR] Directory watcher unexpected error:", err);
+      }
+      logger.debug("Directory watcher aborted");
     }
+    return;
+  })();
+  if (!newSessionFilePath) {
+    logger.debug("No new session file path returned, exiting watcher");
+    return;
   }
-  if (stderrBuffer.trim()) {
-    yield { type: "error", error: stderrBuffer };
-  }
+  logger.debug(`Got session file path: ${newSessionFilePath}, now starting file watcher`);
+  yield* watchSessionFile(newSessionFilePath, abortController);
 }
-function buildArgs(options) {
-  const args = [
-    "--print",
-    options.command,
-    "--output-format",
-    "stream-json",
-    "--verbose"
-  ];
-  if (options.model) {
-    args.push("--model", options.model);
-  }
-  if (options.permissionMode) {
-    const modeMap = {
-      "auto": "acceptEdits",
-      "default": "default",
-      "plan": "bypassPermissions"
-    };
-    args.push("--permission-mode", modeMap[options.permissionMode]);
-  }
-  if (options.skipPermissions) {
-    args.push("--dangerously-skip-permissions");
-  }
-  if (options.sessionId) {
-    args.push("--resume", options.sessionId);
+async function* watchSessionFile(filePath, abortController) {
+  logger.debug(`Watching session file: ${filePath}`);
+  let position = 0;
+  const handle = await open(filePath, "r");
+  const stats = await handle.stat();
+  position = stats.size;
+  await handle.close();
+  logger.debug(`Starting file watch from position: ${position}`);
+  const fileWatcher = watch(filePath, { signal: abortController.signal });
+  try {
+    for await (const event of fileWatcher) {
+      logger.debug(`File watcher event: ${event.eventType}`);
+      if (event.eventType === "change") {
+        logger.debug(`Reading new content from position: ${position}`);
+        const handle2 = await open(filePath, "r");
+        const stream = handle2.createReadStream({ start: position });
+        const rl = createInterface({ input: stream });
+        for await (const line of rl) {
+          try {
+            const message = parseClaudePersistedMessage(JSON.parse(line));
+            if (message) {
+              logger.debug(`[WATCHER] New message from watched session file: ${message.type}`);
+              logger.debugLargeJson("[WATCHER] Message:", message);
+              yield message;
+            } else {
+              logger.debug("[ERROR] Skipping invalid JSON line");
+            }
+          } catch {
+            logger.debug("Skipping invalid JSON line");
+          }
+        }
+        rl.close();
+        await handle2.close();
+        const newHandle = await open(filePath, "r");
+        const stats2 = await newHandle.stat();
+        const oldPosition = position;
+        position = stats2.size;
+        logger.debug(`Updated file position: ${oldPosition} -> ${position}`);
+        await newHandle.close();
+      }
+    }
+  } catch (err) {
+    if (err.name !== "AbortError") {
+      logger.debug("[ERROR] File watcher error:", err);
+      throw err;
+    }
+    logger.debug("File watcher aborted");
   }
-  return args;
 }
 
 function startClaudeLoop(opts, session) {
+  let mode = "interactive";
   let exiting = false;
+  let currentClaudeSessionId;
+  let interactiveProcess = null;
+  let watcherAbortController = null;
   const messageQueue = [];
   let messageResolve = null;
-  let promise = (async () => {
+  const startInteractive = () => {
+    logger.debug("[LOOP] startInteractive called");
+    logger.debug("[LOOP] Current mode:", mode);
+    logger.debug("[LOOP] Current sessionId:", currentClaudeSessionId);
+    logger.debug("[LOOP] Current interactiveProcess:", interactiveProcess ? "exists" : "null");
+    mode = "interactive";
+    session.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser: false
+      // CLI is controlling in interactive mode
+    }));
+    let startWatcher = async () => {
+      watcherAbortController = new AbortController();
+      for await (const event of watchMostRecentSession(opts.path, watcherAbortController)) {
+        if (event.sessionId) {
+          logger.debug(`[LOOP] New session detected from watcher: ${event.sessionId}`);
+          currentClaudeSessionId = event.sessionId;
+          logger.debug("[LOOP] Updated currentSessionId to:", currentClaudeSessionId);
+        }
+        if (event.rawMessage) {
+          if (event.type === "user" && event.rawMessage.message) {
+            const userMessage = {
+              role: "user",
+              localKey: event.rawMessage.uuid,
+              // Use Claude's UUID as localKey
+              sentFrom: "cli",
+              // Identify this as coming from CLI
+              content: {
+                type: "text",
+                text: event.rawMessage.message.content
+              }
+            };
+            session.sendMessage(userMessage);
+          } else if (event.type === "assistant") {
+            session.sendMessage({
+              data: event.rawMessage,
+              type: "output"
+            });
+          }
+        }
+      }
+    };
+    void startWatcher();
+    logger.info(chalk.bold.blue("\u{1F4F1} Happy CLI - Interactive Mode"));
+    if (process.env.DEBUG) {
+      logger.logFilePathPromise.then((path) => {
+        logger.info(`Debug file for this session: ${path}`);
+      });
+    }
+    logger.info("Your session is accessible from your mobile app\n");
+    logger.debug(`[LOOP] About to spawn interactive Claude process (sessionId: ${currentClaudeSessionId})`);
+    interactiveProcess = spawnInteractiveClaude({
+      workingDirectory: opts.path,
+      sessionId: currentClaudeSessionId,
+      model: opts.model,
+      permissionMode: opts.permissionMode
+    });
+    logger.debug("[LOOP] Interactive process spawned");
+    setTimeout(() => {
+      if (interactiveProcess && process.stdout.columns && process.stdout.rows) {
+        const cols = process.stdout.columns;
+        const rows = process.stdout.rows;
+        logger.debug("[LOOP] Force resize timeout fire.d");
+        logger.debug("[LOOP] Terminal size:", { cols, rows });
+        logger.debug("[LOOP] Resizing to cols-1, rows-1");
+        interactiveProcess.resize(cols - 1, rows - 1);
+        setTimeout(() => {
+          logger.debug("[LOOP] Second resize timeout fired");
+          logger.debug("[LOOP] Resizing back to normal size");
+          interactiveProcess?.resize(cols, rows);
+        }, 10);
+      } else {
+        logger.debug("[LOOP] Force resize skipped - no process or invalid terminal size");
+      }
+    }, 100);
+    interactiveProcess.waitForExit().then((code) => {
+      logger.debug("[LOOP] Interactive process exit handler fired, code:", code);
+      logger.debug("[LOOP] Current mode:", mode);
+      logger.debug("[LOOP] Exiting:", exiting);
+      if (!exiting && mode === "interactive") {
+        logger.info(`
+Claude exited with code ${code}`);
+        cleanup();
+      } else {
+        logger.debug("[LOOP] Ignoring exit - was intentional mode switch or already exiting");
+      }
+    });
+  };
+  const requestSwitchToRemote = () => {
+    logger.debug("[LOOP] requestSwitchToRemote called");
+    logger.debug("[LOOP] Current mode before switch:", mode);
+    logger.debug("[LOOP] interactiveProcess exists:", interactiveProcess ? "yes" : "no");
+    mode = "remote";
+    session.updateAgentState((currentState) => ({
+      ...currentState,
+      controlledByUser: true
+      // User is controlling via mobile in remote mode
+    }));
+    if (interactiveProcess) {
+      logger.debug("[LOOP] Killing interactive process");
+      interactiveProcess.kill();
+      logger.debug("[LOOP] Kill called, setting interactiveProcess to null");
+      interactiveProcess = null;
+    } else {
+      logger.debug("[LOOP] No interactive process to kill");
+    }
+    logger.info(chalk.bold.green("\u{1F4F1} Happy CLI - Remote Control Mode"));
+    logger.info(chalk.gray("\u2500".repeat(50)));
+    logger.info("\nYour session is being controlled from the mobile app.");
+    logger.info("\n" + chalk.yellow("Press any key to return to interactive mode..."));
+    process.stdout.write("\n> ");
+    process.stdout.write("\x1B[?25h");
+    logger.debug("[LOOP] Remote UI displayed");
+  };
+  session.addHandler("abort", () => {
+    watcherAbortController?.abort();
+  });
+  const processRemoteMessage = async (message) => {
+    logger.debug("Processing remote message:", message.content.text);
+    opts.onThinking?.(true);
+    watcherAbortController = new AbortController();
+    for await (const output of claude({
+      command: message.content.text,
+      workingDirectory: opts.path,
+      model: opts.model,
+      permissionMode: opts.permissionMode,
+      mcpServers: opts.mcpServers,
+      permissionPromptToolName: opts.permissionPromptToolName,
+      sessionId: currentClaudeSessionId,
+      abort: watcherAbortController
+    })) {
+      if (output.type === "exit") {
+        if (output.code !== 0 || output.code === void 0) {
+          session.sendMessage({
+            type: "error",
+            error: output.error,
+            code: output.code
+          });
+        }
+        break;
+      }
+      if (output.type === "json") {
+        logger.debugLargeJson("[LOOP] Sending message through socket:", output.data);
+        session.sendMessage({
+          data: output.data,
+          type: "output"
+        });
+        const claudeSdkMessage = parseClaudeSdkMessage(output.data);
+        if (claudeSdkMessage) {
+          currentClaudeSessionId = claudeSdkMessage.sessionId;
+          logger.debug(`[LOOP] Updated session ID from SDK: ${currentClaudeSessionId}`);
+          logger.debugLargeJson("[LOOP] Full init data:", output.data);
+        }
+      }
+    }
+    opts.onThinking?.(false);
+  };
+  const run = async () => {
     session.onUserMessage((message) => {
+      logger.debug("Received remote message, adding to queue");
       messageQueue.push(message);
+      if (mode === "interactive") {
+        requestSwitchToRemote();
+      }
       if (messageResolve) {
+        logger.debug("Waking up message processing loop");
         messageResolve();
         messageResolve = null;
       }
     });
+    logger.debug("[LOOP] Setting up stdin input handling");
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    logger.debug("[LOOP] stdin set to raw mode and resumed");
+    process.stdin.on("error", (err) => {
+      logger.debug("[LOOP] stdin error:", err);
+      if (err.code === "EIO") {
+        cleanup();
+        process.exit(0);
+      }
+    });
+    process.stdin.on("data", async (data) => {
+      if (data.toString() === "") {
+        logger.debug("[PTY] Ctrl+C detected");
+        cleanup();
+        process.exit(0);
+        return;
+      }
+      if (mode === "interactive" && interactiveProcess) {
+        interactiveProcess.write(data);
+      } else if (mode === "remote") {
+        logger.debug("[LOOP] Key pressed in remote mode, switching back to interactive");
+        startInteractive();
+      } else {
+        logger.debug("[LOOP] [ERROR] Data received but no action taken");
+      }
+    });
+    process.on("SIGINT", () => {
+      logger.debug("[LOOP] SIGINT received");
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      logger.debug("[LOOP] SIGTERM received");
+      cleanup();
+      process.exit(0);
+    });
+    logger.debug("[LOOP] Initial startup - launching interactive mode");
+    startInteractive();
     while (!exiting) {
-      if (messageQueue.length > 0) {
+      if (mode === "remote" && messageQueue.length > 0) {
         const message = messageQueue.shift();
         if (message) {
-          for await (const output of claude({
-            command: message.content.text,
-            workingDirectory: opts.path,
-            model: opts.model,
-            permissionMode: opts.permissionMode
-          })) {
-            if (output.type === "exit") {
-              if (output.code !== 0 || output.code === void 0) {
-                session.sendMessage({
-                  content: {
-                    type: "error",
-                    error: output.error,
-                    code: output.code
-                  },
-                  role: "assistant"
-                });
-              }
-              break;
-            }
-            if (output.type === "json") {
-              session.sendMessage({
-                data: output.data,
-                type: "output"
-              });
-            }
-          }
+          await processRemoteMessage(message);
         }
+      } else {
+        logger.debug("Waiting for next message or event");
+        await new Promise((resolve) => {
+          messageResolve = resolve;
+        });
       }
-      await new Promise((resolve) => {
-        messageResolve = resolve;
-      });
     }
-  })();
-  return async () => {
+  };
+  const cleanup = () => {
+    logger.debug("[LOOP] cleanup called");
     exiting = true;
+    if (interactiveProcess) {
+      logger.debug("[LOOP] Killing interactive process in cleanup");
+      interactiveProcess.kill();
+    } else {
+      logger.debug("[LOOP] No interactive process to kill in cleanup");
+    }
+    if (watcherAbortController) {
+      logger.debug("[LOOP] Aborting watcher");
+      watcherAbortController.abort();
+    }
     if (messageResolve) {
+      logger.debug("[LOOP] Waking up message loop");
       messageResolve();
     }
+    logger.debug("[LOOP] Setting stdin raw mode to false");
+    process.stdin.setRawMode(false);
+    process.stdin.pause();
+    process.stdout.write("\x1B[?25h");
+  };
+  const promise = run();
+  return async () => {
+    cleanup();
     await promise;
   };
 }
 
+async function startPermissionServer(onPermissionRequest) {
+  const pendingRequests = /* @__PURE__ */ new Map();
+  let lastRequestInput = {};
+  let server;
+  let port = 0;
+  const handleRequest = async (req, res) => {
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (req.method === "OPTIONS") {
+      res.writeHead(200);
+      res.end();
+      return;
+    }
+    if (req.method !== "POST") {
+      res.writeHead(405);
+      res.end(JSON.stringify({ error: "Method not allowed" }));
+      return;
+    }
+    let body = "";
+    req.on("data", (chunk) => body += chunk);
+    req.on("end", async () => {
+      try {
+        const request = JSON.parse(body);
+        logger.debug("[MCP] Request:", request.method, request.params?.name || "");
+        if (request.method === "tools/list") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+              tools: [
+                {
+                  name: "request_permission",
+                  description: "Request permission to execute a tool",
+                  inputSchema: {
+                    type: "object",
+                    properties: {
+                      tool: {
+                        type: "string",
+                        description: "The tool that needs permission"
+                      },
+                      arguments: {
+                        type: "object",
+                        description: "The arguments for the tool"
+                      }
+                    },
+                    required: ["tool", "arguments"]
+                  }
+                }
+              ]
+            }
+          }));
+        } else if (request.method === "tools/call" && request.params?.name === "request_permission") {
+          logger.info(`[MCP] Full request params:`, JSON.stringify(request.params, null, 2));
+          const args = request.params.arguments || {};
+          const { tool_name, input, tool_use_id } = args;
+          lastRequestInput = input || {};
+          const permissionRequest = {
+            id: Math.random().toString(36).substring(7),
+            tool: tool_name || "unknown",
+            arguments: input || {},
+            timestamp: Date.now()
+          };
+          logger.info(`[MCP] Permission request for tool: ${tool_name}`, input);
+          logger.info(`[MCP] Tool use ID: ${tool_use_id}`);
+          onPermissionRequest(permissionRequest);
+          const response = await waitForPermissionResponse(permissionRequest.id);
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: response
+          }));
+        } else if (request.method === "initialize") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: request.id,
+            result: {
+              protocolVersion: "2024-11-05",
+              capabilities: {
+                tools: {}
+              },
+              serverInfo: {
+                name: "permission-server",
+                version: "1.0.0"
+              }
+            }
+          }));
+        } else {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({
+            jsonrpc: "2.0",
+            id: request.id,
+            error: {
+              code: -32601,
+              message: "Method not found"
+            }
+          }));
+        }
+      } catch (error) {
+        logger.debug("[MCP] [ERROR] Request error:", error);
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({
+          jsonrpc: "2.0",
+          error: {
+            code: -32603,
+            message: "Internal error"
+          }
+        }));
+      }
+    });
+  };
+  const waitForPermissionResponse = (id) => {
+    return new Promise((resolve, reject) => {
+      pendingRequests.set(id, { resolve, reject });
+    });
+  };
+  logger.info("[MCP] Starting HTTP permission server...");
+  await new Promise((resolve, reject) => {
+    server = createServer(handleRequest);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (address && typeof address !== "string") {
+        port = address.port;
+        logger.info(`[MCP] HTTP server started on port ${port}`);
+        resolve();
+      } else {
+        reject(new Error("Failed to get server port"));
+      }
+    });
+    server.on("error", (error) => {
+      logger.debug("[MCP] [ERROR] Server error:", error);
+      reject(error);
+    });
+  });
+  return {
+    port,
+    url: `http://localhost:${port}`,
+    toolName: "mcp__permission-server__request_permission",
+    async stop() {
+      logger.debug("[MCP] Stopping HTTP server...");
+      return new Promise((resolve) => {
+        server.close(() => {
+          logger.debug("[MCP] HTTP server stopped");
+          resolve();
+        });
+      });
+    },
+    respondToPermission(response) {
+      const pending = pendingRequests.get(response.id);
+      if (pending) {
+        pendingRequests.delete(response.id);
+        const result = response.approved ? { behavior: "allow", updatedInput: lastRequestInput || {} } : { behavior: "deny", message: response.reason || "Permission denied by user" };
+        pending.resolve({
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result)
+            }
+          ],
+          isError: false
+          // Always false - Claude will parse the JSON to determine error state
+        });
+        logger.debug(`[MCP] Permission response for ${response.id}: ${response.approved}`);
+      } else {
+        logger.debug(`[MCP] No pending request found for ${response.id}`);
+      }
+    }
+  };
+}
+
 async function start(options = {}) {
   const workingDirectory = process.cwd();
-  const projectName = basename(workingDirectory);
+  basename(workingDirectory);
   const sessionTag = randomUUID();
-  logger.info(`Starting happy session for project: ${projectName}`);
-  const secret = await getOrCreateSecretKey();
+  const settings = await readSettings();
+  const needsOnboarding = !settings || !settings.onboardingCompleted;
+  if (needsOnboarding) {
+    logger.info("\n" + chalk.bold.green("\u{1F389} Welcome to Happy CLI!"));
+    logger.info("\nHappy is an open-source, end-to-end encrypted wrapper around Claude Code");
+    logger.info("that allows you to start a regular Claude terminal session with the `happy` command.\n");
+    if (process.platform === "darwin") {
+      logger.info(chalk.yellow("\u{1F4A1} Tip for macOS users:"));
+      logger.info("   Install Amphetamine to prevent your Mac from sleeping during sessions:");
+      logger.info("   https://apps.apple.com/us/app/amphetamine/id937984704?mt=12\n");
+      logger.info("   You can even close your laptop completely while running Amphetamine");
+      logger.info("   and connect through hotspot to your phone for coding on the go!\n");
+    }
+  }
+  let secret = await readPrivateKey();
+  if (!secret) {
+    secret = new Uint8Array(randomBytes(32));
+    await writePrivateKey(secret);
+  }
   logger.info("Secret key loaded");
   const token = await authGetToken(secret);
   logger.info("Authenticated with handy server");
   const api = new ApiClient(token, secret);
-  const response = await api.getOrCreateSession(sessionTag);
-  logger.info(`Session created: ${response.session.id}`);
-  const handyUrl = generateAppUrl(secret);
-  displayQRCode(handyUrl);
-  const session = api.session(response.session.id);
-  const loopDestroy = startClaudeLoop({ path: workingDirectory }, session);
+  let state = {};
+  let metadata = { path: workingDirectory, host: os.hostname() };
+  const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
+  logger.info(`Session created: ${response.id}`);
+  if (needsOnboarding) {
+    const handyUrl = generateAppUrl(secret);
+    displayQRCode(handyUrl);
+    const secretBase64Url = encodeBase64Url(secret);
+    logger.info(`Or manually enter this code: ${secretBase64Url}`);
+    logger.info("\n" + chalk.bold("Press Enter to continue..."));
+    await new Promise((resolve) => {
+      process.stdin.once("data", () => resolve());
+    });
+    await writeSettings({ onboardingCompleted: true });
+  }
+  const session = api.session(response);
+  const permissionServer = await startPermissionServer((request) => {
+    logger.info("Permission request:", request);
+    session.sendMessage({
+      type: "permission-request",
+      data: request
+    });
+  });
+  logger.info(`MCP permission server started on port ${permissionServer.port}`);
+  session.on("message", (message) => {
+    if (message.type === "permission-response") {
+      logger.info("Permission response from client:", message.data);
+      permissionServer.respondToPermission(message.data);
+    }
+  });
+  const mcpServers = {
+    "permission-server": {
+      type: "http",
+      url: permissionServer.url
+    }
+  };
+  let thinking = false;
+  const loopDestroy = startClaudeLoop({
+    path: workingDirectory,
+    model: options.model,
+    permissionMode: options.permissionMode,
+    mcpServers,
+    permissionPromptToolName: permissionServer.toolName,
+    onThinking: (t) => {
+      thinking = t;
+      session.keepAlive(t);
+      session.updateAgentState((currentState) => ({
+        ...currentState,
+        thinking: t
+      }));
+    }
+  }, session);
+  const pingInterval = setInterval(() => {
+    session.keepAlive(thinking);
+  }, 15e3);
   const shutdown = async () => {
     logger.info("Shutting down...");
+    clearInterval(pingInterval);
     await loopDestroy();
+    await permissionServer.stop();
+    session.sendSessionDeath();
+    await session.flush();
     await session.close();
     process.exit(0);
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
-  logger.info("Happy CLI is running. Press Ctrl+C to stop.");
+  logger.info("Happy CLI is starting...");
   await new Promise(() => {
   });
 }
 
 const args = process.argv.slice(2);
-const options = {};
-let showHelp = false;
-let showVersion = 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 === "-m" || arg === "--model") {
-    options.model = args[++i];
-  } else if (arg === "-p" || arg === "--permission-mode") {
-    options.permissionMode = args[++i];
-  } else {
-    console.error(chalk.red(`Unknown argument: ${arg}`));
+const subcommand = args[0];
+if (subcommand === "clean") {
+  cleanKey().catch((error) => {
+    console.error(chalk.red("Error:"), error.message);
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
     process.exit(1);
+  });
+} else {
+  const options = {};
+  let showHelp = false;
+  let showVersion = 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 === "-m" || arg === "--model") {
+      options.model = args[++i];
+    } else if (arg === "-p" || arg === "--permission-mode") {
+      options.permissionMode = args[++i];
+    } else {
+      console.error(chalk.red(`Unknown argument: ${arg}`));
+      process.exit(1);
+    }
   }
-}
-if (showHelp) {
-  console.log(`
+  if (showHelp) {
+    console.log(`
 ${chalk.bold("happy")} - Claude Code session sharing
 
 ${chalk.bold("Usage:")}
   happy [options]
+  happy clean             Remove happy data directory (requires phone reconnection)
 
 ${chalk.bold("Options:")}
   -h, --help              Show this help message
@@ -567,17 +1464,47 @@ ${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 clean             Remove happy data directory and authentication
 `);
-  process.exit(0);
-}
-if (showVersion) {
-  console.log("0.1.0");
-  process.exit(0);
+    process.exit(0);
+  }
+  if (showVersion) {
+    console.log("0.1.0");
+    process.exit(0);
+  }
+  start(options).catch((error) => {
+    console.error(chalk.red("Error:"), error.message);
+    if (process.env.DEBUG) {
+      console.error(error);
+    }
+    process.exit(1);
+  });
 }
-start(options).catch((error) => {
-  console.error(chalk.red("Error:"), error.message);
-  if (process.env.DEBUG) {
-    console.error(error);
+async function cleanKey() {
+  const handyDir = join(homedir(), ".handy");
+  if (!existsSync(handyDir)) {
+    console.log(chalk.yellow("No happy data directory found at:"), handyDir);
+    return;
   }
-  process.exit(1);
-});
+  console.log(chalk.blue("Found happy data directory at:"), handyDir);
+  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(handyDir, { 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"));
+  }
+}