happy-coder 0.1.3 → 0.1.6

package/dist/index.mjs

@@ -1,124 +1,53 @@
-import axios from 'axios';
-import * as fs from 'node:fs';
-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 os, { homedir } from 'node:os';
-import { join, resolve, basename } from 'node:path';
 import chalk from 'chalk';
+import axios from 'axios';
 import { appendFileSync } from 'fs';
+import os, { homedir } from 'node:os';
+import { join, resolve, dirname } from 'node:path';
+import { mkdir, watch as watch$1, readFile, writeFile } from 'node:fs/promises';
+import { existsSync, readFileSync, mkdirSync, watch, rmSync } from 'node:fs';
 import { EventEmitter } from 'node:events';
 import { io } from 'socket.io-client';
-import { z } from 'zod';
-import qrcode from 'qrcode-terminal';
-import { query } from '@anthropic-ai/claude-code';
-import * as pty from 'node-pty';
+import * as z from 'zod';
+import { z as z$1 } from 'zod';
+import { randomBytes, randomUUID } from 'node:crypto';
+import tweetnacl from 'tweetnacl';
+import { Expo } from 'expo-server-sdk';
+import { query, AbortError } from '@anthropic-ai/claude-code';
+import { spawn } from 'node:child_process';
 import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { createServer } from 'node:http';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import qrcode from 'qrcode-terminal';
 
-function encodeBase64(buffer) {
-  return Buffer.from(buffer).toString("base64");
-}
-function encodeBase64Url(buffer) {
-  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
-}
-function decodeBase64(base64) {
-  return new Uint8Array(Buffer.from(base64, "base64"));
-}
-function getRandomBytes(size) {
-  return new Uint8Array(randomBytes(size));
-}
-function encrypt(data, secret) {
-  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
-  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
-  const result = new Uint8Array(nonce.length + encrypted.length);
-  result.set(nonce);
-  result.set(encrypted, nonce.length);
-  return result;
-}
-function decrypt(data, secret) {
-  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
-  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
-  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
-  if (!decrypted) {
-    return null;
-  }
-  return JSON.parse(new TextDecoder().decode(decrypted));
-}
-function authChallenge(secret) {
-  const keypair = tweetnacl.sign.keyPair.fromSeed(secret);
-  const challenge = getRandomBytes(32);
-  const signature = tweetnacl.sign.detached(challenge, keypair.secretKey);
-  return {
-    challenge,
-    publicKey: keypair.publicKey,
-    signature
-  };
-}
-
-async function authGetToken(secret) {
-  const { challenge, publicKey, signature } = authChallenge(secret);
-  const response = await axios.post(`https://handy-api.korshakov.org/v1/auth`, {
-    challenge: encodeBase64(challenge),
-    publicKey: encodeBase64(publicKey),
-    signature: encodeBase64(signature)
-  });
-  if (!response.data.success || !response.data.token) {
-    throw new Error("Authentication failed");
+class Configuration {
+  serverUrl;
+  // Directories and paths (from persistence)
+  happyDir;
+  logsDir;
+  settingsFile;
+  privateKeyFile;
+  constructor(location) {
+    this.serverUrl = process.env.HANDY_SERVER_URL || "https://handy-api.korshakov.org";
+    if (location === "local") {
+      this.happyDir = join(process.cwd(), ".happy");
+    } else {
+      this.happyDir = join(homedir(), ".happy");
+    }
+    this.logsDir = join(this.happyDir, "logs");
+    this.settingsFile = join(this.happyDir, "settings.json");
+    this.privateKeyFile = join(this.happyDir, "access.key");
   }
-  return response.data.token;
 }
-function generateAppUrl(secret) {
-  const secretBase64Url = encodeBase64Url(secret);
-  return `handy://${secretBase64Url}`;
+let configuration = void 0;
+function initializeConfiguration(location) {
+  configuration = new Configuration(location);
 }
 
-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 });
+  if (!existsSync(configuration.logsDir)) {
+    await mkdir(configuration.logsDir, { recursive: true });
   }
   const now = /* @__PURE__ */ new Date();
   const timestamp = now.toLocaleString("sv-SE", {
@@ -130,15 +59,26 @@ async function getSessionLogPath() {
     minute: "2-digit",
     second: "2-digit"
   }).replace(/[: ]/g, "-").replace(/,/g, "");
-  return join(logsDir, `${timestamp}.log`);
+  return join(configuration.logsDir, `${timestamp}.log`);
 }
-
 class Logger {
   constructor(logFilePathPromise = getSessionLogPath()) {
     this.logFilePathPromise = logFilePathPromise;
   }
+  // Use local timezone for simplicity of locating the logs,
+  // in practice you will not need absolute timestamps
+  localTimezoneTimestamp() {
+    return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", {
+      timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      hour12: false,
+      hour: "2-digit",
+      minute: "2-digit",
+      second: "2-digit",
+      fractionalSecondDigits: 3
+    });
+  }
   debug(message, ...args) {
-    this.logToFile(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, message, ...args);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
   }
   debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
     if (!process.env.DEBUG) {
@@ -158,6 +98,9 @@ class Logger {
       if (obj && typeof obj === "object") {
         const result = {};
         for (const [key, value] of Object.entries(obj)) {
+          if (key === "usage") {
+            continue;
+          }
           result[key] = truncateStrings(value);
         }
         return result;
@@ -166,10 +109,11 @@ class Logger {
     };
     const truncatedObject = truncateStrings(object);
     const json = JSON.stringify(truncatedObject, null, 2);
-    this.logToFile(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, message, "\n", json);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, "\n", json);
   }
   info(message, ...args) {
     this.logToConsole("info", "", message, ...args);
+    this.debug(message, args);
   }
   logToConsole(level, prefix, message, ...args) {
     switch (level) {
@@ -202,7 +146,14 @@ class Logger {
     ).join(" ")}
 `;
     this.logFilePathPromise.then((logFilePath) => {
-      appendFileSync(logFilePath, logLine);
+      try {
+        appendFileSync(logFilePath, logLine);
+      } catch (appendError) {
+        if (process.env.DEBUG) {
+          console.error("Failed to append to log file:", appendError);
+          throw appendError;
+        }
+      }
     }).catch((error) => {
       if (process.env.DEBUG) {
         console.log("This message only visible in DEBUG mode, not in production");
@@ -212,87 +163,123 @@ class Logger {
     });
   }
 }
-const logger = new Logger();
+let logger;
+function initLoggerWithGlobalConfiguration() {
+  logger = new Logger();
+}
 
-const SessionMessageContentSchema = z.object({
-  c: z.string(),
+const SessionMessageContentSchema = z$1.object({
+  c: z$1.string(),
   // Base64 encoded encrypted content
-  t: z.literal("encrypted")
+  t: z$1.literal("encrypted")
 });
-const UpdateBodySchema = z.object({
-  message: z.object({
-    id: z.string(),
-    seq: z.number(),
+const UpdateBodySchema = z$1.object({
+  message: z$1.object({
+    id: z$1.string(),
+    seq: z$1.number(),
     content: SessionMessageContentSchema
   }),
-  sid: z.string(),
+  sid: z$1.string(),
   // Session ID
-  t: z.literal("new-message")
+  t: z$1.literal("new-message")
 });
-const UpdateSessionBodySchema = z.object({
-  t: z.literal("update-session"),
-  sid: z.string(),
-  metadata: z.object({
-    version: z.number(),
-    metadata: z.string()
+const UpdateSessionBodySchema = z$1.object({
+  t: z$1.literal("update-session"),
+  sid: z$1.string(),
+  metadata: z$1.object({
+    version: z$1.number(),
+    metadata: z$1.string()
   }).nullish(),
-  agentState: z.object({
-    version: z.number(),
-    agentState: z.string()
+  agentState: z$1.object({
+    version: z$1.number(),
+    agentState: z$1.string()
   }).nullish()
 });
-z.object({
-  id: z.string(),
-  seq: z.number(),
-  body: z.union([UpdateBodySchema, UpdateSessionBodySchema]),
-  createdAt: z.number()
+z$1.object({
+  id: z$1.string(),
+  seq: z$1.number(),
+  body: z$1.union([UpdateBodySchema, UpdateSessionBodySchema]),
+  createdAt: z$1.number()
 });
-z.object({
-  createdAt: z.number(),
-  id: z.string(),
-  seq: z.number(),
-  updatedAt: z.number(),
-  metadata: z.any(),
-  metadataVersion: z.number(),
-  agentState: z.any().nullable(),
-  agentStateVersion: z.number()
+z$1.object({
+  createdAt: z$1.number(),
+  id: z$1.string(),
+  seq: z$1.number(),
+  updatedAt: z$1.number(),
+  metadata: z$1.any(),
+  metadataVersion: z$1.number(),
+  agentState: z$1.any().nullable(),
+  agentStateVersion: z$1.number()
 });
-z.object({
+z$1.object({
   content: SessionMessageContentSchema,
-  createdAt: z.number(),
-  id: z.string(),
-  seq: z.number(),
-  updatedAt: z.number()
+  createdAt: z$1.number(),
+  id: z$1.string(),
+  seq: z$1.number(),
+  updatedAt: z$1.number()
 });
-z.object({
-  session: z.object({
-    id: z.string(),
-    tag: z.string(),
-    seq: z.number(),
-    createdAt: z.number(),
-    updatedAt: z.number(),
-    metadata: z.string(),
-    metadataVersion: z.number(),
-    agentState: z.string().nullable(),
-    agentStateVersion: z.number()
+z$1.object({
+  session: z$1.object({
+    id: z$1.string(),
+    tag: z$1.string(),
+    seq: z$1.number(),
+    createdAt: z$1.number(),
+    updatedAt: z$1.number(),
+    metadata: z$1.string(),
+    metadataVersion: z$1.number(),
+    agentState: z$1.string().nullable(),
+    agentStateVersion: z$1.number()
   })
 });
-const UserMessageSchema = z.object({
-  role: z.literal("user"),
-  content: z.object({
-    type: z.literal("text"),
-    text: z.string()
+const UserMessageSchema$1 = z$1.object({
+  role: z$1.literal("user"),
+  content: z$1.object({
+    type: z$1.literal("text"),
+    text: z$1.string()
   }),
-  localKey: z.string().optional(),
+  localKey: z$1.string().optional(),
   // Mobile messages include this
-  sentFrom: z.enum(["mobile", "cli"]).optional()
+  sentFrom: z$1.enum(["mobile", "cli"]).optional()
   // Source identifier
 });
-const AgentMessageSchema = z.object({
-  role: z.literal("agent"),
-  content: z.any()
+const AgentMessageSchema = z$1.object({
+  role: z$1.literal("agent"),
+  content: z$1.object({
+    type: z$1.literal("output"),
+    data: z$1.any()
+  })
 });
-z.union([UserMessageSchema, AgentMessageSchema]);
+z$1.union([UserMessageSchema$1, AgentMessageSchema]);
+
+function encodeBase64(buffer) {
+  return Buffer.from(buffer).toString("base64");
+}
+function encodeBase64Url(buffer) {
+  return Buffer.from(buffer).toString("base64").replaceAll("+", "-").replaceAll("/", "_").replaceAll("=", "");
+}
+function decodeBase64(base64) {
+  return new Uint8Array(Buffer.from(base64, "base64"));
+}
+function getRandomBytes(size) {
+  return new Uint8Array(randomBytes(size));
+}
+function encrypt(data, secret) {
+  const nonce = getRandomBytes(tweetnacl.secretbox.nonceLength);
+  const encrypted = tweetnacl.secretbox(new TextEncoder().encode(JSON.stringify(data)), nonce, secret);
+  const result = new Uint8Array(nonce.length + encrypted.length);
+  result.set(nonce);
+  result.set(encrypted, nonce.length);
+  return result;
+}
+function decrypt(data, secret) {
+  const nonce = data.slice(0, tweetnacl.secretbox.nonceLength);
+  const encrypted = data.slice(tweetnacl.secretbox.nonceLength);
+  const decrypted = tweetnacl.secretbox.open(encrypted, nonce, secret);
+  if (!decrypted) {
+    return null;
+  }
+  return JSON.parse(new TextDecoder().decode(decrypted));
+}
 
 async function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -331,8 +318,6 @@ class ApiSessionClient extends EventEmitter {
   agentState;
   agentStateVersion;
   socket;
-  receivedMessages = /* @__PURE__ */ new Set();
-  sentLocalKeys = /* @__PURE__ */ new Set();
   pendingMessages = [];
   pendingMessageCallback = null;
   rpcHandlers = /* @__PURE__ */ new Map();
@@ -345,9 +330,11 @@ class ApiSessionClient extends EventEmitter {
     this.metadataVersion = session.metadataVersion;
     this.agentState = session.agentState;
     this.agentStateVersion = session.agentStateVersion;
-    this.socket = io("https://handy-api.korshakov.org", {
+    this.socket = io(configuration.serverUrl, {
       auth: {
-        token: this.token
+        token: this.token,
+        clientType: "session-scoped",
+        sessionId: this.sessionId
       },
       path: "/v1/updates",
       reconnection: true,
@@ -359,7 +346,7 @@ class ApiSessionClient extends EventEmitter {
       autoConnect: false
     });
     this.socket.on("connect", () => {
-      logger.info("Socket connected successfully");
+      logger.debug("Socket connected successfully");
       this.reregisterHandlers();
     });
     this.socket.on("rpc-request", async (data, callback) => {
@@ -388,24 +375,18 @@ class ApiSessionClient extends EventEmitter {
       logger.debug("[API] Socket disconnected:", reason);
     });
     this.socket.on("connect_error", (error) => {
-      logger.debug("[API] Socket connection error:", error.message);
+      logger.debug("[API] Socket connection error:", error);
     });
     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);
         logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
-        const userResult = UserMessageSchema.safeParse(body);
+        const userResult = UserMessageSchema$1.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(userResult.data);
-            } else {
-              this.pendingMessages.push(userResult.data);
-            }
+          if (this.pendingMessageCallback) {
+            this.pendingMessageCallback(userResult.data);
+          } else {
+            this.pendingMessages.push(userResult.data);
           }
         } else {
           this.emit("message", body);
@@ -421,6 +402,9 @@ class ApiSessionClient extends EventEmitter {
         }
       }
     });
+    this.socket.on("error", (error) => {
+      logger.debug("[API] Socket error:", error);
+    });
     this.socket.connect();
   }
   onUserMessage(callback) {
@@ -433,21 +417,27 @@ class ApiSessionClient extends EventEmitter {
    * Send message to session
    * @param body - Message body (can be MessageContent or raw content for agent messages)
    */
-  sendMessage(body) {
-    logger.debugLargeJson("[SOCKET] Sending message through socket:", body);
+  sendClaudeSessionMessage(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}`);
-      }
+    if (body.type === "user" && typeof body.message.content === "string") {
+      content = {
+        role: "user",
+        content: {
+          type: "text",
+          text: body.message.content
+        }
+      };
     } else {
       content = {
         role: "agent",
-        content: body
+        content: {
+          type: "output",
+          data: body
+          // This wraps the entire Claude message
+        }
       };
     }
+    logger.debugLargeJson("[SOCKET] Sending message through socket:", content);
     const encrypted = encodeBase64(encrypt(content, this.secret));
     this.socket.emit("message", {
       sid: this.sessionId,
@@ -491,27 +481,31 @@ class ApiSessionClient extends EventEmitter {
    * @param handler - Handler function that returns the updated agent state
    */
   updateAgentState(handler) {
+    console.log("Updating agent state", this.agentState);
     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 });
+      const answer = await this.socket.emitWithAck("update-state", { 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;
+        console.log("Agent state updated", this.agentState);
       } 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") ;
+      } else if (answer.result === "error") {
+        console.error("Agent state update error", answer);
+      }
     });
   }
   /**
-   * Add a custom RPC handler for a specific method with encrypted arguments and responses
+   * Set 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) {
+  setHandler(method, handler) {
     const prefixedMethod = `${this.sessionId}:${method}`;
     this.rpcHandlers.set(prefixedMethod, handler);
     this.socket.emit("rpc-register", { method: prefixedMethod });
@@ -550,12 +544,119 @@ class ApiSessionClient extends EventEmitter {
   }
 }
 
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expo;
+  constructor(token, baseUrl = "https://handy-api.korshakov.org") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+    this.expo = new Expo();
+  }
+  /**
+   * Fetch all push tokens for the authenticated user
+   */
+  async fetchPushTokens() {
+    try {
+      const response = await axios.get(
+        `${this.baseUrl}/v1/push-tokens`,
+        {
+          headers: {
+            "Authorization": `Bearer ${this.token}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      logger.info(`Fetched ${response.data.tokens.length} push tokens`);
+      return response.data.tokens;
+    } catch (error) {
+      logger.debug("[PUSH] [ERROR] Failed to fetch push tokens:", error);
+      throw new Error(`Failed to fetch push tokens: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Send push notification via Expo Push API with retry
+   * @param messages - Array of push messages to send
+   */
+  async sendPushNotifications(messages) {
+    logger.info(`Sending ${messages.length} push notifications`);
+    const validMessages = messages.filter((message) => {
+      if (Array.isArray(message.to)) {
+        return message.to.every((token) => Expo.isExpoPushToken(token));
+      }
+      return Expo.isExpoPushToken(message.to);
+    });
+    if (validMessages.length === 0) {
+      logger.info("No valid Expo push tokens found");
+      return;
+    }
+    const chunks = this.expo.chunkPushNotifications(validMessages);
+    for (const chunk of chunks) {
+      const startTime = Date.now();
+      const timeout = 3e5;
+      let attempt = 0;
+      while (true) {
+        try {
+          const ticketChunk = await this.expo.sendPushNotificationsAsync(chunk);
+          const errors = ticketChunk.filter((ticket) => ticket.status === "error");
+          if (errors.length > 0) {
+            logger.debug("[PUSH] Some notifications failed:", errors);
+          }
+          if (errors.length === ticketChunk.length) {
+            throw new Error("All push notifications in chunk failed");
+          }
+          break;
+        } catch (error) {
+          const elapsed = Date.now() - startTime;
+          if (elapsed >= timeout) {
+            logger.debug("[PUSH] Timeout reached after 5 minutes, giving up on chunk");
+            break;
+          }
+          attempt++;
+          const delay = Math.min(1e3 * Math.pow(2, attempt), 3e4);
+          const remainingTime = timeout - elapsed;
+          const waitTime = Math.min(delay, remainingTime);
+          if (waitTime > 0) {
+            logger.debug(`[PUSH] Retrying in ${waitTime}ms (attempt ${attempt})`);
+            await new Promise((resolve) => setTimeout(resolve, waitTime));
+          }
+        }
+      }
+    }
+    logger.info(`Push notifications sent successfully`);
+  }
+  /**
+   * Send a push notification to all registered devices for the user
+   * @param title - Notification title
+   * @param body - Notification body
+   * @param data - Additional data to send with the notification
+   */
+  async sendToAllDevices(title, body, data) {
+    const tokens = await this.fetchPushTokens();
+    if (tokens.length === 0) {
+      logger.info("No push tokens found for user");
+      return;
+    }
+    const messages = tokens.map((token) => ({
+      to: token.token,
+      title,
+      body,
+      data,
+      sound: "default",
+      priority: "high"
+    }));
+    await this.sendPushNotifications(messages);
+  }
+}
+
 class ApiClient {
   token;
   secret;
+  pushClient;
   constructor(token, secret) {
     this.token = token;
     this.secret = secret;
+    this.pushClient = new PushNotificationClient(token);
   }
   /**
    * Create a new session or load existing one with the given tag
@@ -563,7 +664,7 @@ class ApiClient {
   async getOrCreateSession(opts) {
     try {
       const response = await axios.post(
-        `https://handy-api.korshakov.org/v1/sessions`,
+        `${configuration.serverUrl}/v1/sessions`,
         {
           tag: opts.tag,
           metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
@@ -576,7 +677,7 @@ class ApiClient {
           }
         }
       );
-      logger.info(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
       let raw = response.data.session;
       let session = {
         id: raw.id,
@@ -602,857 +703,1220 @@ class ApiClient {
   session(session) {
     return new ApiSessionClient(this.token, this.secret, session);
   }
+  /**
+   * Get push notification client
+   * @returns Push notification client
+   */
+  push() {
+    return this.pushClient;
+  }
 }
 
-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);
+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;
     }
-  });
-  logger.info(`\u{1F4CB} Or use this URL: ${url}`);
-}
-
-async function* claude(options) {
-  try {
-    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
-    });
-    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 };
+    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);
+                }
+              }
+            }
           }
-          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 };
+        } 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;
-        default:
-          yield { type: "json", data: message };
+        }
+      }
+      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);
       }
     }
-  } catch (error) {
-    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 printDivider() {
+  console.log(chalk.gray("\u2550".repeat(60)));
 }
 
-function claudePath() {
-  if (fs.existsSync(process.env.HOME + "/.claude/local/claude")) {
-    return process.env.HOME + "/.claude/local/claude";
-  } else {
-    return "claude";
+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;
 }
 
-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);
+async function claudeRemote(opts) {
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
   }
-  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,
-    env: process.env
+  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("[PTY] PTY process created, pid:", ptyProcess.pid);
-  ptyProcess.onData((data) => {
-    process.stdout.write(data);
+  logger.debug(`[claudeRemote] Starting query with messages`);
+  response = query({
+    prompt: opts.messages,
+    abortController,
+    options: sdkOptions
   });
-  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);
+  if (opts.interruptController) {
+    opts.interruptController.register(async () => {
+      logger.debug("[claudeRemote] Interrupting Claude via SDK");
+      await response.interrupt();
     });
-  });
-  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);
-    }
-  };
-}
-
-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
+  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();
+          }
+        });
+      }
     }
-  };
-}
-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
+    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`);
 }
 
-async function* watchMostRecentSession(workingDirectory, abortController) {
-  const projectName = resolve(workingDirectory).replace(/\//g, "-");
+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);
-  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 });
-  }
-  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 {
-      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;
-            }
-          }
-        }
+  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;
       }
-    } catch (err) {
-      if (err.name !== "AbortError") {
-        logger.debug("[ERROR] Directory watcher unexpected error:", err);
+      if (detectedIdsRandomUUID.has(sessionId)) {
+        resolvedSessionId = sessionId;
+        opts.onSessionFound(sessionId);
       }
-      logger.debug("Directory watcher aborted");
     }
-    return;
-  })();
-  if (!newSessionFilePath) {
-    logger.debug("No new session file path returned, exiting watcher");
-    return;
+  });
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
   }
-  logger.debug(`Got session file path: ${newSessionFilePath}, now starting file watcher`);
-  yield* watchSessionFile(newSessionFilePath, abortController);
-}
-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");
+    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]);
             }
-          } 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();
+        });
+        rl.on("error", (err) => {
+          console.error("Error reading from fd 3:", err);
+        });
       }
-    }
-  } catch (err) {
-    if (err.name !== "AbortError") {
-      logger.debug("[ERROR] File watcher error:", err);
-      throw err;
-    }
-    logger.debug("File watcher aborted");
-  }
+      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;
 }
 
-function startClaudeLoop(opts, session) {
-  let mode = "interactive";
-  let exiting = false;
-  let currentClaudeSessionId;
-  let interactiveProcess = null;
-  let watcherAbortController = null;
-  const messageQueue = [];
-  let messageResolve = null;
-  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}`);
+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.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");
+    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;
       }
-    }, 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");
+      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 = [];
   };
-  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;
+  _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 {
-      logger.debug("[LOOP] No interactive process to kill");
+      this._invalidated = false;
+      this._notifyPendings();
     }
-    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;
+}
+
+const UsageSchema = z$1.object({
+  input_tokens: z$1.number().int().nonnegative(),
+  cache_creation_input_tokens: z$1.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z$1.number().int().nonnegative().optional(),
+  output_tokens: z$1.number().int().nonnegative(),
+  service_tier: z$1.string().optional()
+});
+const TextContentSchema = z$1.object({
+  type: z$1.literal("text"),
+  text: z$1.string()
+});
+const ThinkingContentSchema = z$1.object({
+  type: z$1.literal("thinking"),
+  thinking: z$1.string(),
+  signature: z$1.string()
+});
+const ToolUseContentSchema = z$1.object({
+  type: z$1.literal("tool_use"),
+  id: z$1.string(),
+  name: z$1.string(),
+  input: z$1.unknown()
+  // Tool-specific input parameters
+});
+const ToolResultContentSchema = z$1.object({
+  tool_use_id: z$1.string(),
+  type: z$1.literal("tool_result"),
+  content: z$1.union([
+    z$1.string(),
+    // For simple string responses
+    z$1.array(TextContentSchema)
+    // For structured content blocks (typically text)
+  ]),
+  is_error: z$1.boolean().optional()
+});
+const ContentSchema = z$1.union([
+  TextContentSchema,
+  ThinkingContentSchema,
+  ToolUseContentSchema,
+  ToolResultContentSchema
+]);
+const UserMessageSchema = z$1.object({
+  role: z$1.literal("user"),
+  content: z$1.union([
+    z$1.string(),
+    // Simple string content
+    z$1.array(z$1.union([ToolResultContentSchema, TextContentSchema]))
+  ])
+});
+const AssistantMessageSchema = z$1.object({
+  id: z$1.string(),
+  type: z$1.literal("message"),
+  role: z$1.literal("assistant"),
+  model: z$1.string(),
+  content: z$1.array(ContentSchema),
+  stop_reason: z$1.string().nullable(),
+  stop_sequence: z$1.string().nullable(),
+  usage: UsageSchema
+});
+const BaseEntrySchema = z$1.object({
+  cwd: z$1.string(),
+  sessionId: z$1.string(),
+  version: z$1.string(),
+  uuid: z$1.string(),
+  timestamp: z$1.string().datetime(),
+  parent_tool_use_id: z$1.string().nullable().optional()
+});
+const SummaryEntrySchema = z$1.object({
+  type: z$1.literal("summary"),
+  summary: z$1.string(),
+  leafUuid: z$1.string()
+});
+const UserEntrySchema = BaseEntrySchema.extend({
+  type: z$1.literal("user"),
+  message: UserMessageSchema,
+  isMeta: z$1.boolean().optional(),
+  toolUseResult: z$1.unknown().optional()
+  // Present when user responds to tool use
+});
+const AssistantEntrySchema = BaseEntrySchema.extend({
+  type: z$1.literal("assistant"),
+  message: AssistantMessageSchema,
+  requestId: z$1.string().optional()
+});
+const SystemEntrySchema = BaseEntrySchema.extend({
+  type: z$1.literal("system"),
+  content: z$1.string(),
+  isMeta: z$1.boolean().optional(),
+  level: z$1.string().optional(),
+  parentUuid: z$1.string().optional(),
+  isSidechain: z$1.boolean().optional(),
+  userType: z$1.string().optional()
+});
+const RawJSONLinesSchema = z$1.discriminatedUnion("type", [
+  UserEntrySchema,
+  AssistantEntrySchema,
+  SummaryEntrySchema,
+  SystemEntrySchema
+]);
+
+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();
+  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;
       }
-      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);
+      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}`);
+          opts.onMessage(parsed.data);
+        } catch (e) {
+          continue;
         }
       }
+    };
+    for (let session of sessions) {
+      await processSessionFile(session);
     }
-    opts.onThinking?.(false);
-  };
-  const run = async () => {
-    session.onUserMessage((message) => {
-      logger.debug("Received remote message, adding to queue");
-      messageQueue.push(message);
-      if (mode === "interactive") {
-        requestSwitchToRemote();
+    for (let p of sessions) {
+      if (pendingSessions.has(p)) {
+        pendingSessions.delete(p);
+        finishedSessions.add(p);
       }
-      if (messageResolve) {
-        logger.debug("Waking up message processing loop");
-        messageResolve();
-        messageResolve = null;
+    }
+    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}`);
+          }
+        }
       }
-    });
-    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);
+    })();
+  });
+  const intervalId = setInterval(() => {
+    sync.invalidate();
+  }, 3e3);
+  return {
+    refresh: () => sync.invalidate(),
+    cleanup: () => {
+      clearInterval(intervalId);
+      currentSessionWatcherAbortController?.abort();
+    },
+    onNewSession: (sessionId) => {
+      if (currentSessionId === sessionId) {
+        return;
       }
-    });
-    process.stdin.on("data", async (data) => {
-      if (data.toString() === "") {
-        logger.debug("[PTY] Ctrl+C detected");
-        cleanup();
-        process.exit(0);
+      if (finishedSessions.has(sessionId)) {
         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");
+      if (pendingSessions.has(sessionId)) {
+        return;
       }
-    });
-    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 (mode === "remote" && messageQueue.length > 0) {
-        const message = messageQueue.shift();
-        if (message) {
-          await processRemoteMessage(message);
+      if (currentSessionId) {
+        pendingSessions.add(currentSessionId);
+      }
+      currentSessionId = sessionId;
+      sync.invalidate();
+    }
+  };
+}
+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 = "interactive";
+  let currentMessageQueue = new MessageQueue();
+  let sessionId = null;
+  let onMessage = null;
+  let seenRemoteUserMessageCounters = /* @__PURE__ */ new Map();
+  opts.session.onUserMessage((message) => {
+    logger.debugLargeJson("User message pushed to queue:", message);
+    currentMessageQueue.push(message.content.text);
+    seenRemoteUserMessageCounters.set(message.content.text, (seenRemoteUserMessageCounters.get(message.content.text) || 0) + 1);
+    if (onMessage) {
+      onMessage();
+    }
+  });
+  const sessionScanner = createSessionScanner({
+    workingDirectory: opts.path,
+    onMessage: (message) => {
+      if (message.type === "user" && typeof message.message.content === "string") {
+        const currentCounter = seenRemoteUserMessageCounters.get(message.message.content);
+        if (currentCounter && currentCounter > 0) {
+          seenRemoteUserMessageCounters.set(message.message.content, currentCounter - 1);
+          return;
         }
-      } else {
-        logger.debug("Waiting for next message or event");
-        await new Promise((resolve) => {
-          messageResolve = resolve;
-        });
       }
+      opts.session.sendClaudeSessionMessage(message);
     }
+  });
+  let onSessionFound = (newSessionId) => {
+    sessionId = newSessionId;
+    sessionScanner.onNewSession(newSessionId);
   };
-  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");
+  while (true) {
+    if (currentMessageQueue.size() > 0) {
+      mode = "remote";
+      continue;
     }
-    if (watcherAbortController) {
-      logger.debug("[LOOP] Aborting watcher");
-      watcherAbortController.abort();
+    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 (messageResolve) {
-      logger.debug("[LOOP] Waking up message loop");
-      messageResolve();
+    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();
+        }
+        process.stdin.setRawMode(false);
+      };
+      process.stdin.resume();
+      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);
+        process.stdin.setRawMode(false);
+        currentMessageQueue.close();
+        currentMessageQueue = new MessageQueue();
+      }
+      if (mode !== "remote") {
+        console.log("Switching back to good old claude...");
+      }
     }
-    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;
+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")
     }
-    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"
-            }
-          }));
+    // 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)
         }
-      } 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"
-          }
-        }));
+      ],
+      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 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);
+    }
+  });
+  const baseUrl = await new Promise((resolve) => {
     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);
+      const addr = server.address();
+      resolve(new URL(`http://127.0.0.1:${addr.port}`));
     });
   });
   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}`);
-      }
-    }
+    url: baseUrl.toString(),
+    toolName: "ask_permission"
   };
 }
 
-async function start(options = {}) {
-  const workingDirectory = process.cwd();
-  basename(workingDirectory);
-  const sessionTag = randomUUID();
-  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");
+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;
     }
   }
-  let secret = await readPrivateKey();
-  if (!secret) {
-    secret = new Uint8Array(randomBytes(32));
-    await writePrivateKey(secret);
+  /**
+   * Check if interrupt is available
+   */
+  canInterrupt() {
+    return !!this.interruptFn && !this.isInterrupting;
   }
-  logger.info("Secret key loaded");
-  const token = await authGetToken(secret);
-  logger.info("Authenticated with handy server");
-  const api = new ApiClient(token, secret);
+}
+
+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() };
   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 });
-  }
+  logger.debug(`Session created: ${response.id}`);
   const session = api.session(response);
-  const permissionServer = await startPermissionServer((request) => {
-    logger.info("Permission request:", request);
-    session.sendMessage({
-      type: "permission-request",
-      data: request
+  const pushClient = api.push();
+  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;
   });
-  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);
+  session.setHandler("permission", (message) => {
+    logger.info("Permission response" + JSON.stringify(message));
+    const id = message.id;
+    const resolve = requests.get(id);
+    if (resolve) {
+      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 mcpServers = {
-    "permission-server": {
-      type: "http",
-      url: permissionServer.url
+  let thinking = false;
+  const pingInterval = setInterval(() => {
+    session.keepAlive(thinking);
+  }, 15e3);
+  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);
     }
   };
-  let thinking = false;
-  const loopDestroy = startClaudeLoop({
+  await loop({
     path: workingDirectory,
     model: options.model,
     permissionMode: options.permissionMode,
-    mcpServers,
-    permissionPromptToolName: permissionServer.toolName,
+    mcpServers: {
+      "permission": {
+        type: "http",
+        url: permissionServer.url
+      }
+    },
+    permissionPromptToolName: "mcp__permission__" + 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 starting...");
-  await new Promise(() => {
+    },
+    session,
+    onAssistantResult,
+    interruptController
   });
+  clearInterval(pingInterval);
+  process.exit(0);
+}
+
+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));
 }
 
-const args = process.argv.slice(2);
-const subcommand = args[0];
-if (subcommand === "clean") {
-  cleanKey().catch((error) => {
-    console.error(chalk.red("Error:"), error.message);
-    if (process.env.DEBUG) {
-      console.error(error);
+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);
     }
-    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);
+  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");
+  displayQRCode("happy://terminal?" + encodeBase64Url(keypair.publicKey));
+  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);
   }
-  if (showHelp) {
-    console.log(`
+  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 === "login" || subcommand === "auth") {
+    await doAuth();
+    return;
+  } 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 if (arg === "--local") {
+        i++;
+      } 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 clean             Remove happy data directory (requires phone reconnection)
+  happy logout     Logs out of your account and removes data directory
+  happy login      Show your secret QR code
+  happy auth       Same as login
 
 ${chalk.bold("Options:")}
   -h, --help              Show this help message
@@ -1460,33 +1924,50 @@ ${chalk.bold("Options:")}
   -m, --model <model>     Claude model to use (default: sonnet)
   -p, --permission-mode   Permission mode: auto, default, or plan
 
+  [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.
+      Use with login to show either global or local QR code.
+
 ${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
+  happy logout            Logs out of your account and removes data directory
 `);
-    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(0);
     }
-    process.exit(1);
-  });
-}
+    if (showVersion) {
+      console.log("0.1.3");
+      process.exit(0);
+    }
+    let credentials = await readCredentials();
+    if (!credentials) {
+      let res = await doAuth();
+      if (!res) {
+        process.exit(1);
+      }
+      credentials = res;
+    }
+    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 handyDir = join(homedir(), ".handy");
-  if (!existsSync(handyDir)) {
-    console.log(chalk.yellow("No happy data directory found at:"), handyDir);
+  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:"), handyDir);
+  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,
@@ -1498,7 +1979,7 @@ async function cleanKey() {
   rl.close();
   if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
     try {
-      rmSync(handyDir, { recursive: true, force: true });
+      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) {