happy-coder 0.1.2 → 0.1.5

package/dist/index.cjs

@@ -1,19 +1,28 @@
 'use strict';
 
+var chalk = require('chalk');
 var axios = require('axios');
-var fs = require('node:fs');
-var promises = require('node:fs/promises');
-var node_crypto = require('node:crypto');
-var tweetnacl = require('tweetnacl');
+var fs = require('fs');
 var os = require('node:os');
 var node_path = require('node:path');
-var chalk = require('chalk');
+var promises = require('node:fs/promises');
+var node_fs = require('node:fs');
 var node_events = require('node:events');
 var socket_ioClient = require('socket.io-client');
-var zod = require('zod');
-var qrcode = require('qrcode-terminal');
+var z = require('zod');
+var node_crypto = require('node:crypto');
+var tweetnacl = require('tweetnacl');
+var expoServerSdk = require('expo-server-sdk');
+var claudeCode = require('@anthropic-ai/claude-code');
 var node_child_process = require('node:child_process');
+var node_readline = require('node:readline');
+var node_url = require('node:url');
+var mcp_js = require('@modelcontextprotocol/sdk/server/mcp.js');
+var node_http = require('node:http');
+var streamableHttp_js = require('@modelcontextprotocol/sdk/server/streamableHttp.js');
+var qrcode = require('qrcode-terminal');
 
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
   if (e) {
@@ -31,193 +40,322 @@ function _interopNamespaceDefault(e) {
   return Object.freeze(n);
 }
 
-var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs);
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
-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(node_crypto.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;
+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 = node_path.join(process.cwd(), ".happy");
+    } else {
+      this.happyDir = node_path.join(os.homedir(), ".happy");
+    }
+    this.logsDir = node_path.join(this.happyDir, "logs");
+    this.settingsFile = node_path.join(this.happyDir, "settings.json");
+    this.privateKeyFile = node_path.join(this.happyDir, "access.key");
   }
-  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
-  };
+let configuration = void 0;
+function initializeConfiguration(location) {
+  configuration = new Configuration(location);
 }
 
-async function getOrCreateSecretKey() {
-  const keyPath = node_path.join(os.homedir(), ".handy", "access.key");
-  if (fs.existsSync(keyPath)) {
-    const keyBase642 = fs.readFileSync(keyPath, "utf8").trim();
-    return new Uint8Array(Buffer.from(keyBase642, "base64"));
-  }
-  const secret = getRandomBytes(32);
-  const keyBase64 = encodeBase64(secret);
-  fs.mkdirSync(node_path.join(os.homedir(), ".handy"), { recursive: true });
-  fs.writeFileSync(keyPath, keyBase64);
-  await promises.chmod(keyPath, 384);
-  return secret;
-}
-async function authGetToken(secret) {
-  const { challenge, publicKey, signature } = authChallenge(secret);
-  const response = await axios.post(`https://handy-api.korshakov.org/v1/auth`, {
-    challenge: encodeBase64(challenge),
-    publicKey: encodeBase64(publicKey),
-    signature: encodeBase64(signature)
-  });
-  if (!response.data.success || !response.data.token) {
-    throw new Error("Authentication failed");
+async function getSessionLogPath() {
+  if (!node_fs.existsSync(configuration.logsDir)) {
+    await promises.mkdir(configuration.logsDir, { recursive: true });
   }
-  return response.data.token;
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = now.toLocaleString("sv-SE", {
+    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit"
+  }).replace(/[: ]/g, "-").replace(/,/g, "");
+  return node_path.join(configuration.logsDir, `${timestamp}.log`);
 }
-function generateAppUrl(secret) {
-  const secretBase64Url = encodeBase64Url(secret);
-  return `handy://${secretBase64Url}`;
-}
-
 class Logger {
-  debug(message, ...args) {
-    if (process.env.DEBUG) {
-      this.log("DEBUG" /* DEBUG */, message, ...args);
-    }
+  constructor(logFilePathPromise = getSessionLogPath()) {
+    this.logFilePathPromise = logFilePathPromise;
   }
-  error(message, ...args) {
-    this.log("ERROR" /* ERROR */, message, ...args);
+  // 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
+    });
   }
-  info(message, ...args) {
-    this.log("INFO" /* INFO */, message, ...args);
+  debug(message, ...args) {
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, ...args);
   }
-  warn(message, ...args) {
-    this.log("WARN" /* WARN */, message, ...args);
+  debugLargeJson(message, object, maxStringLength = 100, maxArrayLength = 10) {
+    if (!process.env.DEBUG) {
+      this.debug(`In production, skipping message inspection`);
+    }
+    const truncateStrings = (obj) => {
+      if (typeof obj === "string") {
+        return obj.length > maxStringLength ? obj.substring(0, maxStringLength) + "... [truncated for logs]" : obj;
+      }
+      if (Array.isArray(obj)) {
+        const truncatedArray = obj.map((item) => truncateStrings(item)).slice(0, maxArrayLength);
+        if (obj.length > maxArrayLength) {
+          truncatedArray.push(`... [truncated array for logs up to ${maxArrayLength} items]`);
+        }
+        return truncatedArray;
+      }
+      if (obj && typeof obj === "object") {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+          if (key === "usage") {
+            continue;
+          }
+          result[key] = truncateStrings(value);
+        }
+        return result;
+      }
+      return obj;
+    };
+    const truncatedObject = truncateStrings(object);
+    const json = JSON.stringify(truncatedObject, null, 2);
+    this.logToFile(`[${this.localTimezoneTimestamp()}]`, message, "\n", json);
   }
-  getTimestamp() {
-    return (/* @__PURE__ */ new Date()).toISOString();
+  info(message, ...args) {
+    this.logToConsole("info", "", message, ...args);
+    this.debug(message, args);
   }
-  log(level, message, ...args) {
-    const timestamp = this.getTimestamp();
-    const prefix = `[${timestamp}] [${level}]`;
+  logToConsole(level, prefix, message, ...args) {
     switch (level) {
-      case "DEBUG" /* DEBUG */: {
+      case "debug": {
         console.log(chalk.gray(prefix), message, ...args);
         break;
       }
-      case "ERROR" /* ERROR */: {
+      case "error": {
         console.error(chalk.red(prefix), message, ...args);
         break;
       }
-      case "INFO" /* INFO */: {
+      case "info": {
         console.log(chalk.blue(prefix), message, ...args);
         break;
       }
-      case "WARN" /* WARN */: {
+      case "warn": {
         console.log(chalk.yellow(prefix), message, ...args);
         break;
       }
+      default: {
+        this.debug("Unknown log level:", level);
+        console.log(chalk.blue(prefix), message, ...args);
+        break;
+      }
     }
   }
+  logToFile(prefix, message, ...args) {
+    const logLine = `${prefix} ${message} ${args.map(
+      (arg) => typeof arg === "string" ? arg : JSON.stringify(arg)
+    ).join(" ")}
+`;
+    this.logFilePathPromise.then((logFilePath) => {
+      try {
+        fs.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");
+        console.error("Failed to resolve log file path:", error);
+        console.log(prefix, message, ...args);
+      }
+    });
+  }
+}
+let logger;
+function initLoggerWithGlobalConfiguration() {
+  logger = new Logger();
 }
-const logger = new Logger();
 
-const SessionMessageContentSchema = zod.z.object({
-  c: zod.z.string(),
+const SessionMessageContentSchema = z.z.object({
+  c: z.z.string(),
   // Base64 encoded encrypted content
-  t: zod.z.literal("encrypted")
+  t: z.z.literal("encrypted")
 });
-const UpdateBodySchema = zod.z.object({
-  message: zod.z.object({
-    id: zod.z.string(),
-    seq: zod.z.number(),
+const UpdateBodySchema = z.z.object({
+  message: z.z.object({
+    id: z.z.string(),
+    seq: z.z.number(),
     content: SessionMessageContentSchema
   }),
-  sid: zod.z.string(),
+  sid: z.z.string(),
   // Session ID
-  t: zod.z.literal("new-message")
+  t: z.z.literal("new-message")
 });
-zod.z.object({
-  id: zod.z.string(),
-  seq: zod.z.number(),
-  body: UpdateBodySchema,
-  createdAt: zod.z.number()
+const UpdateSessionBodySchema = z.z.object({
+  t: z.z.literal("update-session"),
+  sid: z.z.string(),
+  metadata: z.z.object({
+    version: z.z.number(),
+    metadata: z.z.string()
+  }).nullish(),
+  agentState: z.z.object({
+    version: z.z.number(),
+    agentState: z.z.string()
+  }).nullish()
 });
-zod.z.object({
-  createdAt: zod.z.number(),
-  id: zod.z.string(),
-  seq: zod.z.number(),
-  updatedAt: zod.z.number()
+z.z.object({
+  id: z.z.string(),
+  seq: z.z.number(),
+  body: z.z.union([UpdateBodySchema, UpdateSessionBodySchema]),
+  createdAt: z.z.number()
 });
-zod.z.object({
+z.z.object({
+  createdAt: z.z.number(),
+  id: z.z.string(),
+  seq: z.z.number(),
+  updatedAt: z.z.number(),
+  metadata: z.z.any(),
+  metadataVersion: z.z.number(),
+  agentState: z.z.any().nullable(),
+  agentStateVersion: z.z.number()
+});
+z.z.object({
   content: SessionMessageContentSchema,
-  createdAt: zod.z.number(),
-  id: zod.z.string(),
-  seq: zod.z.number(),
-  updatedAt: zod.z.number()
+  createdAt: z.z.number(),
+  id: z.z.string(),
+  seq: z.z.number(),
+  updatedAt: z.z.number()
 });
-zod.z.object({
-  session: zod.z.object({
-    id: zod.z.string(),
-    tag: zod.z.string(),
-    seq: zod.z.number(),
-    createdAt: zod.z.number(),
-    updatedAt: zod.z.number()
+z.z.object({
+  session: z.z.object({
+    id: z.z.string(),
+    tag: z.z.string(),
+    seq: z.z.number(),
+    createdAt: z.z.number(),
+    updatedAt: z.z.number(),
+    metadata: z.z.string(),
+    metadataVersion: z.z.number(),
+    agentState: z.z.string().nullable(),
+    agentStateVersion: z.z.number()
   })
 });
-const UserMessageSchema = zod.z.object({
-  role: zod.z.literal("user"),
-  content: zod.z.object({
-    type: zod.z.literal("text"),
-    text: zod.z.string()
-  })
+const UserMessageSchema$1 = z.z.object({
+  role: z.z.literal("user"),
+  content: z.z.object({
+    type: z.z.literal("text"),
+    text: z.z.string()
+  }),
+  localKey: z.z.string().optional(),
+  // Mobile messages include this
+  sentFrom: z.z.enum(["mobile", "cli"]).optional()
+  // Source identifier
 });
-const AgentMessageSchema = zod.z.object({
-  role: zod.z.literal("agent"),
-  content: zod.z.any()
+const AgentMessageSchema = z.z.object({
+  role: z.z.literal("agent"),
+  content: z.z.object({
+    type: z.z.literal("output"),
+    data: z.z.any()
+  })
 });
-zod.z.union([UserMessageSchema, AgentMessageSchema]);
+z.z.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(node_crypto.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));
+}
+function exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount) {
+  let maxDelayRet = minDelay + (maxDelay - minDelay) / maxFailureCount * Math.max(currentFailureCount, maxFailureCount);
+  return Math.round(Math.random() * maxDelayRet);
+}
+function createBackoff(opts) {
+  return async (callback) => {
+    let currentFailureCount = 0;
+    const minDelay = 250;
+    const maxDelay = 1e3;
+    const maxFailureCount = 50;
+    while (true) {
+      try {
+        return await callback();
+      } catch (e) {
+        if (currentFailureCount < maxFailureCount) {
+          currentFailureCount++;
+        }
+        let waitForRequest = exponentialBackoffDelay(currentFailureCount, minDelay, maxDelay, maxFailureCount);
+        await delay(waitForRequest);
+      }
+    }
+  };
+}
+let backoff = createBackoff();
 
 class ApiSessionClient extends node_events.EventEmitter {
   token;
   secret;
   sessionId;
+  metadata;
+  metadataVersion;
+  agentState;
+  agentStateVersion;
   socket;
-  receivedMessages = /* @__PURE__ */ new Set();
   pendingMessages = [];
   pendingMessageCallback = null;
-  constructor(token, secret, sessionId) {
+  rpcHandlers = /* @__PURE__ */ new Map();
+  constructor(token, secret, session) {
     super();
     this.token = token;
     this.secret = secret;
-    this.sessionId = sessionId;
-    this.socket = socket_ioClient.io("https://handy-api.korshakov.org", {
+    this.sessionId = session.id;
+    this.metadata = session.metadata;
+    this.metadataVersion = session.metadataVersion;
+    this.agentState = session.agentState;
+    this.agentStateVersion = session.agentStateVersion;
+    this.socket = socket_ioClient.io(configuration.serverUrl, {
       auth: {
-        token: this.token
+        token: this.token,
+        clientType: "session-scoped",
+        sessionId: this.sessionId
       },
       path: "/v1/updates",
       reconnection: true,
@@ -229,30 +367,65 @@ class ApiSessionClient extends node_events.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) => {
+      try {
+        const method = data.method;
+        const handler = this.rpcHandlers.get(method);
+        if (!handler) {
+          logger.debug("[SOCKET] [RPC] [ERROR] method not found", { method });
+          const errorResponse = { error: "Method not found" };
+          const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+          callback(encryptedError);
+          return;
+        }
+        const decryptedParams = decrypt(decodeBase64(data.params), this.secret);
+        const result = await handler(decryptedParams);
+        const encryptedResponse = encodeBase64(encrypt(result, this.secret));
+        callback(encryptedResponse);
+      } catch (error) {
+        logger.debug("[SOCKET] [RPC] [ERROR] Error handling RPC request", { error });
+        const errorResponse = { error: error instanceof Error ? error.message : "Unknown error" };
+        const encryptedError = encodeBase64(encrypt(errorResponse, this.secret));
+        callback(encryptedError);
+      }
     });
     this.socket.on("disconnect", (reason) => {
-      logger.warn("Socket disconnected:", reason);
+      logger.debug("[API] Socket disconnected:", reason);
     });
     this.socket.on("connect_error", (error) => {
-      logger.error("Socket connection error:", error.message);
+      logger.debug("[API] Socket connection error:", error);
     });
     this.socket.on("update", (data) => {
       if (data.body.t === "new-message" && data.body.message.content.t === "encrypted") {
         const body = decrypt(decodeBase64(data.body.message.content.c), this.secret);
-        const result = UserMessageSchema.safeParse(body);
-        if (result.success) {
-          if (!this.receivedMessages.has(data.body.message.id)) {
-            this.receivedMessages.add(data.body.message.id);
-            if (this.pendingMessageCallback) {
-              this.pendingMessageCallback(result.data);
-            } else {
-              this.pendingMessages.push(result.data);
-            }
+        logger.debugLargeJson("[SOCKET] [UPDATE] Received update:", body);
+        const userResult = UserMessageSchema$1.safeParse(body);
+        if (userResult.success) {
+          if (this.pendingMessageCallback) {
+            this.pendingMessageCallback(userResult.data);
+          } else {
+            this.pendingMessages.push(userResult.data);
           }
+        } else {
+          this.emit("message", body);
+        }
+      } else if (data.body.t === "update-session") {
+        if (data.body.metadata && data.body.metadata.version > this.metadataVersion) {
+          this.metadata = decrypt(decodeBase64(data.body.metadata.metadata), this.secret);
+          this.metadataVersion = data.body.metadata.version;
+        }
+        if (data.body.agentState && data.body.agentState.version > this.agentStateVersion) {
+          this.agentState = data.body.agentState.agentState ? decrypt(decodeBase64(data.body.agentState.agentState), this.secret) : null;
+          this.agentStateVersion = data.body.agentState.version;
         }
       }
     });
+    this.socket.on("error", (error) => {
+      logger.debug("[API] Socket error:", error);
+    });
     this.socket.connect();
   }
   onUserMessage(callback) {
@@ -263,30 +436,248 @@ class ApiSessionClient extends node_events.EventEmitter {
   }
   /**
    * Send message to session
-   * @param body - Message body
+   * @param body - Message body (can be MessageContent or raw content for agent messages)
    */
-  sendMessage(body) {
-    let content = {
-      role: "agent",
-      content: body
-    };
+  sendClaudeSessionMessage(body) {
+    let content;
+    if (body.type === "user" && typeof body.message.content === "string") {
+      content = {
+        role: "user",
+        content: {
+          type: "text",
+          text: body.message.content
+        }
+      };
+    } else {
+      content = {
+        role: "agent",
+        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,
       message: encrypted
     });
   }
+  /**
+   * Send a ping message to keep the connection alive
+   */
+  keepAlive(thinking) {
+    this.socket.volatile.emit("session-alive", { sid: this.sessionId, time: Date.now(), thinking });
+  }
+  /**
+   * Send session death message
+   */
+  sendSessionDeath() {
+    this.socket.emit("session-end", { sid: this.sessionId, time: Date.now() });
+  }
+  /**
+   * Update session metadata
+   * @param handler - Handler function that returns the updated metadata
+   */
+  updateMetadata(handler) {
+    backoff(async () => {
+      let updated = handler(this.metadata);
+      const answer = await this.socket.emitWithAck("update-metadata", { sid: this.sessionId, expectedVersion: this.metadataVersion, metadata: encodeBase64(encrypt(updated, this.secret)) });
+      if (answer.result === "success") {
+        this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        this.metadataVersion = answer.version;
+      } else if (answer.result === "version-mismatch") {
+        if (answer.version > this.metadataVersion) {
+          this.metadataVersion = answer.version;
+          this.metadata = decrypt(decodeBase64(answer.metadata), this.secret);
+        }
+        throw new Error("Metadata version mismatch");
+      } else if (answer.result === "error") ;
+    });
+  }
+  /**
+   * Update session agent state
+   * @param handler - Handler function that returns the updated agent state
+   */
+  updateAgentState(handler) {
+    console.log("Updating agent state", this.agentState);
+    backoff(async () => {
+      let updated = handler(this.agentState || {});
+      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") {
+        console.error("Agent state update error", answer);
+      }
+    });
+  }
+  /**
+   * 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
+   */
+  setHandler(method, handler) {
+    const prefixedMethod = `${this.sessionId}:${method}`;
+    this.rpcHandlers.set(prefixedMethod, handler);
+    this.socket.emit("rpc-register", { method: prefixedMethod });
+    logger.debug("Registered RPC handler", { method, prefixedMethod });
+  }
+  /**
+   * Re-register all RPC handlers after reconnection
+   */
+  reregisterHandlers() {
+    logger.debug("Re-registering RPC handlers after reconnection", {
+      totalMethods: this.rpcHandlers.size
+    });
+    for (const [prefixedMethod] of this.rpcHandlers) {
+      this.socket.emit("rpc-register", { method: prefixedMethod });
+      logger.debug("Re-registered method", { prefixedMethod });
+    }
+  }
+  /**
+   * Wait for socket buffer to flush
+   */
+  async flush() {
+    if (!this.socket.connected) {
+      return;
+    }
+    return new Promise((resolve) => {
+      this.socket.emit("ping", () => {
+        resolve();
+      });
+      setTimeout(() => {
+        resolve();
+      }, 1e4);
+    });
+  }
   async close() {
     this.socket.close();
   }
 }
 
+class PushNotificationClient {
+  token;
+  baseUrl;
+  expo;
+  constructor(token, baseUrl = "https://handy-api.korshakov.org") {
+    this.token = token;
+    this.baseUrl = baseUrl;
+    this.expo = new expoServerSdk.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) => expoServerSdk.Expo.isExpoPushToken(token));
+      }
+      return expoServerSdk.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
@@ -294,8 +685,12 @@ class ApiClient {
   async getOrCreateSession(opts) {
     try {
       const response = await axios.post(
-        `https://handy-api.korshakov.org/v1/sessions`,
-        { tag: opts.tag, metadata: encodeBase64(encrypt(opts.metadata, this.secret)) },
+        `${configuration.serverUrl}/v1/sessions`,
+        {
+          tag: opts.tag,
+          metadata: encodeBase64(encrypt(opts.metadata, this.secret)),
+          agentState: opts.state ? encodeBase64(encrypt(opts.state, this.secret)) : null
+        },
         {
           headers: {
             "Authorization": `Bearer ${this.token}`,
@@ -303,10 +698,21 @@ class ApiClient {
           }
         }
       );
-      logger.info(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
-      return response.data;
+      logger.debug(`Session created/loaded: ${response.data.session.id} (tag: ${opts.tag})`);
+      let raw = response.data.session;
+      let session = {
+        id: raw.id,
+        createdAt: raw.createdAt,
+        updatedAt: raw.updatedAt,
+        seq: raw.seq,
+        metadata: decrypt(decodeBase64(raw.metadata), this.secret),
+        metadataVersion: raw.metadataVersion,
+        agentState: raw.agentState ? decrypt(decodeBase64(raw.agentState), this.secret) : null,
+        agentStateVersion: raw.agentStateVersion
+      };
+      return session;
     } catch (error) {
-      logger.error("Failed to get or create session:", error);
+      logger.debug("[API] [ERROR] Failed to get or create session:", error);
       throw new Error(`Failed to get or create session: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
@@ -315,272 +721,1223 @@ class ApiClient {
    * @param id - Session ID
    * @returns Session client
    */
-  session(id) {
-    return new ApiSessionClient(this.token, this.secret, id);
+  session(session) {
+    return new ApiSessionClient(this.token, this.secret, session);
+  }
+  /**
+   * Get push notification client
+   * @returns Push notification client
+   */
+  push() {
+    return this.pushClient;
   }
 }
 
-function displayQRCode(url) {
-  try {
-    logger.info("=".repeat(50));
-    logger.info("\u{1F4F1} Scan this QR code with your mobile device:");
-    logger.info("=".repeat(50));
-    qrcode.generate(url, { small: true }, (qr) => {
-      for (let l of qr.split("\n")) {
-        logger.info("         " + l);
+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)));
       }
-    });
-    logger.info("=".repeat(50));
-  } catch (error) {
-    logger.error("Failed to generate QR code:", error);
-    logger.info(`\u{1F4CB} Use this URL to connect: ${url}`);
+      break;
+    }
+    case "user": {
+      const userMsg = message;
+      if (userMsg.message && typeof userMsg.message === "object" && "content" in userMsg.message) {
+        const content = userMsg.message.content;
+        if (typeof content === "string") {
+          console.log(chalk.magenta.bold("\n\u{1F464} User:"), content);
+        } else if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "text") {
+              console.log(chalk.magenta.bold("\n\u{1F464} User:"), block.text);
+            } else if (block.type === "tool_result") {
+              console.log(chalk.green.bold("\n\u2705 Tool Result:"), chalk.gray(`(Tool ID: ${block.tool_use_id})`));
+              if (block.content) {
+                const outputStr = typeof block.content === "string" ? block.content : JSON.stringify(block.content, null, 2);
+                const maxLength = 200;
+                if (outputStr.length > maxLength) {
+                  console.log(outputStr.substring(0, maxLength) + chalk.gray("\n... (truncated)"));
+                } else {
+                  console.log(outputStr);
+                }
+              }
+            }
+          }
+        } else {
+          console.log(chalk.magenta.bold("\n\u{1F464} User:"), JSON.stringify(content, null, 2));
+        }
+      }
+      break;
+    }
+    case "assistant": {
+      const assistantMsg = message;
+      if (assistantMsg.message && assistantMsg.message.content) {
+        console.log(chalk.cyan.bold("\n\u{1F916} Assistant:"));
+        for (const block of assistantMsg.message.content) {
+          if (block.type === "text") {
+            console.log(block.text);
+          } else if (block.type === "tool_use") {
+            console.log(chalk.yellow.bold(`
+\u{1F527} Tool: ${block.name}`));
+            if (block.input) {
+              const inputStr = JSON.stringify(block.input, null, 2);
+              const maxLength = 500;
+              if (inputStr.length > maxLength) {
+                console.log(chalk.gray("Input:"), inputStr.substring(0, maxLength) + chalk.gray("\n... (truncated)"));
+              } else {
+                console.log(chalk.gray("Input:"), inputStr);
+              }
+            }
+          }
+        }
+      }
+      break;
+    }
+    case "result": {
+      const resultMsg = message;
+      if (resultMsg.subtype === "success") {
+        if ("result" in resultMsg && resultMsg.result) {
+          console.log(chalk.green.bold("\n\u2728 Summary:"));
+          console.log(resultMsg.result);
+        }
+        if (resultMsg.usage) {
+          console.log(chalk.gray("\n\u{1F4CA} Session Stats:"));
+          console.log(chalk.gray(`  \u2022 Turns: ${resultMsg.num_turns}`));
+          console.log(chalk.gray(`  \u2022 Input tokens: ${resultMsg.usage.input_tokens}`));
+          console.log(chalk.gray(`  \u2022 Output tokens: ${resultMsg.usage.output_tokens}`));
+          if (resultMsg.usage.cache_read_input_tokens) {
+            console.log(chalk.gray(`  \u2022 Cache read tokens: ${resultMsg.usage.cache_read_input_tokens}`));
+          }
+          if (resultMsg.usage.cache_creation_input_tokens) {
+            console.log(chalk.gray(`  \u2022 Cache creation tokens: ${resultMsg.usage.cache_creation_input_tokens}`));
+          }
+          console.log(chalk.gray(`  \u2022 Cost: $${resultMsg.total_cost_usd.toFixed(4)}`));
+          console.log(chalk.gray(`  \u2022 Duration: ${resultMsg.duration_ms}ms`));
+          console.log(chalk.gray("\n\u{1F440} Back already?"));
+          console.log(chalk.green("\u{1F449} Press any key to continue your session in `claude`"));
+          if (onAssistantResult) {
+            Promise.resolve(onAssistantResult(resultMsg)).catch((err) => {
+              logger.debug("Error in onAssistantResult callback:", err);
+            });
+          }
+        }
+      } else if (resultMsg.subtype === "error_max_turns") {
+        console.log(chalk.red.bold("\n\u274C Error: Maximum turns reached"));
+        console.log(chalk.gray(`Completed ${resultMsg.num_turns} turns`));
+      } else if (resultMsg.subtype === "error_during_execution") {
+        console.log(chalk.red.bold("\n\u274C Error during execution"));
+        console.log(chalk.gray(`Completed ${resultMsg.num_turns} turns before error`));
+        logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
+      }
+      break;
+    }
+    default: {
+      const exhaustiveCheck = message;
+      if (process.env.DEBUG) {
+        console.log(chalk.gray(`[Unknown message type]`), exhaustiveCheck);
+      }
+    }
   }
 }
+function printDivider() {
+  console.log(chalk.gray("\u2550".repeat(60)));
+}
 
-function claudePath() {
-  if (fs__namespace.existsSync(process.env.HOME + "/.claude/local/claude")) {
-    return process.env.HOME + "/.claude/local/claude";
-  } else {
-    return "claude";
+function claudeCheckSession(sessionId, path) {
+  const projectName = node_path.resolve(path).replace(/\//g, "-");
+  const projectDir = node_path.join(os.homedir(), ".claude", "projects", projectName);
+  const sessionFile = node_path.join(projectDir, `${sessionId}.jsonl`);
+  const sessionExists = node_fs.existsSync(sessionFile);
+  if (!sessionExists) {
+    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    return false;
   }
+  const sessionData = node_fs.readFileSync(sessionFile, "utf-8").split("\n");
+  const hasGoodMessage = !!sessionData.find((v) => {
+    try {
+      return typeof JSON.parse(v).uuid === "string";
+    } catch (e) {
+      return false;
+    }
+  });
+  return hasGoodMessage;
 }
 
-async function* claude(options) {
-  const args = buildArgs(options);
-  const path = claudePath();
-  logger.info("Spawning Claude CLI with args:", args);
-  const process = node_child_process.spawn(path, args, {
-    cwd: options.workingDirectory,
-    stdio: ["pipe", "pipe", "pipe"],
-    shell: false
-  });
-  process.stdin?.end();
-  let outputBuffer = "";
-  let stderrBuffer = "";
-  let processExited = false;
-  const outputQueue = [];
-  let outputResolve = null;
-  process.stdout?.on("data", (data) => {
-    outputBuffer += data.toString();
-    const lines = outputBuffer.split("\n");
-    outputBuffer = lines.pop() || "";
-    for (const line of lines) {
-      if (line.trim()) {
-        try {
-          const json = JSON.parse(line);
-          outputQueue.push({ type: "json", data: json });
-        } catch {
-          outputQueue.push({ type: "text", data: line });
-        }
-        if (outputResolve) {
-          outputResolve();
-          outputResolve = null;
-        }
+async function claudeRemote(opts) {
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
+  }
+  const abortController = new AbortController();
+  const sdkOptions = {
+    cwd: opts.path,
+    resume: startFrom ?? void 0,
+    mcpServers: opts.mcpServers,
+    permissionPromptToolName: opts.permissionPromptToolName,
+    executable: "node",
+    abortController
+  };
+  let aborted = false;
+  let response;
+  opts.abort.addEventListener("abort", () => {
+    if (!aborted) {
+      aborted = true;
+      if (response) {
+        (async () => {
+          try {
+            const r = await response.interrupt();
+          } catch (e) {
+          }
+          abortController.abort();
+        })();
+      } else {
+        abortController.abort();
       }
     }
   });
-  process.stderr?.on("data", (data) => {
-    stderrBuffer += data.toString();
-    const lines = stderrBuffer.split("\n");
-    stderrBuffer = lines.pop() || "";
-    for (const line of lines) {
-      if (line.trim()) {
-        outputQueue.push({ type: "error", error: line });
-        if (outputResolve) {
-          outputResolve();
-          outputResolve = null;
-        }
+  logger.debug(`[claudeRemote] Starting query with messages`);
+  response = claudeCode.query({
+    prompt: opts.messages,
+    abortController,
+    options: sdkOptions
+  });
+  if (opts.interruptController) {
+    opts.interruptController.register(async () => {
+      logger.debug("[claudeRemote] Interrupting Claude via SDK");
+      await response.interrupt();
+    });
+  }
+  printDivider();
+  try {
+    logger.debug(`[claudeRemote] Starting to iterate over response`);
+    for await (const message of response) {
+      logger.debug(`[claudeRemote] Received message from SDK: ${message.type}`);
+      formatClaudeMessage(message, opts.onAssistantResult);
+      if (message.type === "system" && message.subtype === "init") {
+        const projectName = node_path.resolve(opts.path).replace(/\//g, "-");
+        const projectDir = node_path.join(os.homedir(), ".claude", "projects", projectName);
+        node_fs.mkdirSync(projectDir, { recursive: true });
+        const watcher = node_fs.watch(projectDir).on("change", (_, filename) => {
+          if (filename === `${message.session_id}.jsonl`) {
+            opts.onSessionFound(message.session_id);
+            watcher.close();
+          }
+        });
       }
     }
-  });
-  process.on("exit", (code, signal) => {
-    processExited = true;
-    outputQueue.push({ type: "exit", code, signal });
-    if (outputResolve) {
-      outputResolve();
-      outputResolve = null;
+    logger.debug(`[claudeRemote] Finished iterating over response`);
+  } catch (e) {
+    if (abortController.signal.aborted) {
+      logger.debug(`[claudeRemote] Aborted`);
     }
-  });
-  process.on("error", (error) => {
-    outputQueue.push({ type: "error", error: error.message });
-    processExited = true;
-    if (outputResolve) {
-      outputResolve();
-      outputResolve = null;
+    if (e instanceof claudeCode.AbortError) {
+      logger.debug(`[claudeRemote] Aborted`);
+    } else {
+      throw e;
+    }
+  } finally {
+    if (opts.interruptController) {
+      opts.interruptController.unregister();
+    }
+  }
+  printDivider();
+  logger.debug(`[claudeRemote] Function completed`);
+}
+
+const __dirname$1 = node_path.dirname(node_url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href))));
+async function claudeLocal(opts) {
+  const projectName = node_path.resolve(opts.path).replace(/\//g, "-");
+  const projectDir = node_path.join(os.homedir(), ".claude", "projects", projectName);
+  node_fs.mkdirSync(projectDir, { recursive: true });
+  const watcher = node_fs.watch(projectDir);
+  let resolvedSessionId = null;
+  const detectedIdsRandomUUID = /* @__PURE__ */ new Set();
+  const detectedIdsFileSystem = /* @__PURE__ */ new Set();
+  watcher.on("change", (event, filename) => {
+    if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
+      logger.debug("change", event, filename);
+      const sessionId = filename.replace(".jsonl", "");
+      if (detectedIdsFileSystem.has(sessionId)) {
+        return;
+      }
+      detectedIdsFileSystem.add(sessionId);
+      if (resolvedSessionId) {
+        return;
+      }
+      if (detectedIdsRandomUUID.has(sessionId)) {
+        resolvedSessionId = sessionId;
+        opts.onSessionFound(sessionId);
+      }
     }
   });
-  while (!processExited || outputQueue.length > 0) {
-    if (outputQueue.length === 0) {
-      await new Promise((resolve) => {
-        outputResolve = resolve;
-        if (outputQueue.length > 0 || processExited) {
-          resolve();
-          outputResolve = null;
+  let startFrom = opts.sessionId;
+  if (opts.sessionId && !claudeCheckSession(opts.sessionId, opts.path)) {
+    startFrom = null;
+  }
+  try {
+    process.stdin.pause();
+    await new Promise((r, reject) => {
+      const args = [];
+      if (startFrom) {
+        args.push("--resume", startFrom);
+      }
+      const claudeCliPath = process.env.HAPPY_CLAUDE_CLI_PATH || node_path.resolve(node_path.join(__dirname$1, "..", "scripts", "claudeInteractiveLaunch.cjs"));
+      const child = node_child_process.spawn("node", [claudeCliPath, ...args], {
+        stdio: ["inherit", "inherit", "inherit", "pipe"],
+        signal: opts.abort,
+        cwd: opts.path
+      });
+      if (child.stdio[3]) {
+        const rl = node_readline.createInterface({
+          input: child.stdio[3],
+          crlfDelay: Infinity
+        });
+        rl.on("line", (line) => {
+          const sessionMatch = line.match(/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/i);
+          if (sessionMatch) {
+            detectedIdsRandomUUID.add(sessionMatch[0]);
+            if (resolvedSessionId) {
+              return;
+            }
+            if (detectedIdsFileSystem.has(sessionMatch[0])) {
+              resolvedSessionId = sessionMatch[0];
+              opts.onSessionFound(sessionMatch[0]);
+            }
+          }
+        });
+        rl.on("error", (err) => {
+          console.error("Error reading from fd 3:", err);
+        });
+      }
+      child.on("error", (error) => {
+      });
+      child.on("exit", (code, signal) => {
+        if (signal === "SIGTERM" && opts.abort.aborted) {
+          r();
+        } else if (signal) {
+          reject(new Error(`Process terminated with signal: ${signal}`));
+        } else {
+          r();
         }
       });
+    });
+  } finally {
+    watcher.close();
+    process.stdin.resume();
+  }
+  return resolvedSessionId;
+}
+
+class MessageQueue {
+  queue = [];
+  waiters = [];
+  closed = false;
+  closePromise;
+  closeResolve;
+  constructor() {
+    this.closePromise = new Promise((resolve) => {
+      this.closeResolve = resolve;
+    });
+  }
+  /**
+   * Push a message to the queue
+   */
+  push(message) {
+    if (this.closed) {
+      throw new Error("Cannot push to closed queue");
     }
-    while (outputQueue.length > 0) {
-      const output = outputQueue.shift();
-      yield output;
+    logger.debug(`[MessageQueue] push() called. Waiters: ${this.waiters.length}, Queue size before: ${this.queue.length}`);
+    const waiter = this.waiters.shift();
+    if (waiter) {
+      logger.debug(`[MessageQueue] Found waiter! Delivering message directly: "${message}"`);
+      waiter({
+        type: "user",
+        message: {
+          role: "user",
+          content: message
+        },
+        parent_tool_use_id: null,
+        session_id: ""
+      });
+    } else {
+      logger.debug(`[MessageQueue] No waiter found. Adding to queue: "${message}"`);
+      this.queue.push({
+        type: "user",
+        message: {
+          role: "user",
+          content: message
+        },
+        parent_tool_use_id: null,
+        session_id: ""
+      });
     }
+    logger.debug(`[MessageQueue] push() completed. Waiters: ${this.waiters.length}, Queue size after: ${this.queue.length}`);
   }
-  if (outputBuffer.trim()) {
-    try {
-      const json = JSON.parse(outputBuffer);
-      yield { type: "json", data: json };
-    } catch {
-      yield { type: "text", data: outputBuffer };
-    }
-  }
-  if (stderrBuffer.trim()) {
-    yield { type: "error", error: stderrBuffer };
-  }
-}
-function buildArgs(options) {
-  const args = [
-    "--print",
-    options.command,
-    "--output-format",
-    "stream-json",
-    "--verbose"
-  ];
-  if (options.model) {
-    args.push("--model", options.model);
-  }
-  if (options.permissionMode) {
-    const modeMap = {
-      "auto": "acceptEdits",
-      "default": "default",
-      "plan": "bypassPermissions"
-    };
-    args.push("--permission-mode", modeMap[options.permissionMode]);
+  /**
+   * Close the queue - no more messages can be pushed
+   */
+  close() {
+    logger.debug(`[MessageQueue] close() called. Waiters: ${this.waiters.length}`);
+    this.closed = true;
+    this.closeResolve?.();
   }
-  if (options.skipPermissions) {
-    args.push("--dangerously-skip-permissions");
+  /**
+   * Check if the queue is closed
+   */
+  isClosed() {
+    return this.closed;
+  }
+  /**
+   * Get the current queue size
+   */
+  size() {
+    return this.queue.length;
+  }
+  /**
+   * Async iterator implementation
+   */
+  async *[Symbol.asyncIterator]() {
+    logger.debug(`[MessageQueue] Iterator started`);
+    while (true) {
+      const message = this.queue.shift();
+      if (message !== void 0) {
+        logger.debug(`[MessageQueue] Iterator yielding queued message`);
+        yield message;
+        continue;
+      }
+      if (this.closed) {
+        logger.debug(`[MessageQueue] Iterator ending - queue closed`);
+        return;
+      }
+      logger.debug(`[MessageQueue] Iterator waiting for next message...`);
+      const nextMessage = await this.waitForNext();
+      if (nextMessage === void 0) {
+        logger.debug(`[MessageQueue] Iterator ending - no more messages`);
+        return;
+      }
+      logger.debug(`[MessageQueue] Iterator yielding waited message`);
+      yield nextMessage;
+    }
   }
-  if (options.sessionId) {
-    args.push("--resume", options.sessionId);
+  /**
+   * 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);
+        }
+      });
+    });
   }
-  return args;
 }
 
-function startClaudeLoop(opts, session) {
-  let exiting = false;
-  const messageQueue = [];
-  let messageResolve = null;
-  let sessionId;
-  let promise = (async () => {
-    session.onUserMessage((message) => {
-      messageQueue.push(message);
-      if (messageResolve) {
-        messageResolve();
-        messageResolve = null;
+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();
     });
-    while (!exiting) {
-      if (messageQueue.length > 0) {
-        const message = messageQueue.shift();
-        if (message) {
-          for await (const output of claude({
-            command: message.content.text,
-            workingDirectory: opts.path,
-            model: opts.model,
-            permissionMode: opts.permissionMode,
-            sessionId
-          })) {
-            if (output.type === "exit") {
-              if (output.code !== 0 || output.code === void 0) {
-                session.sendMessage({
-                  content: {
-                    type: "error",
-                    error: output.error,
-                    code: output.code
-                  },
-                  role: "assistant"
-                });
-              }
-              break;
-            }
-            if (output.type === "json") {
-              session.sendMessage({
-                data: output.data,
-                type: "output"
-              });
-            }
-            if (output.type === "json" && output.data.type === "system" && output.data.subtype === "init") {
-              sessionId = output.data.sessionId;
-            }
+  }
+  stop() {
+    if (this._stopped) {
+      return;
+    }
+    this._notifyPendings();
+    this._stopped = true;
+  }
+  _notifyPendings = () => {
+    for (let pending of this._pendings) {
+      pending();
+    }
+    this._pendings = [];
+  };
+  _doSync = async () => {
+    await backoff(async () => {
+      if (this._stopped) {
+        return;
+      }
+      await this._command();
+    });
+    if (this._stopped) {
+      this._notifyPendings();
+      return;
+    }
+    if (this._invalidatedDouble) {
+      this._invalidatedDouble = false;
+      this._doSync();
+    } else {
+      this._invalidated = false;
+      this._notifyPendings();
+    }
+  };
+}
+
+const UsageSchema = z.z.object({
+  input_tokens: z.z.number().int().nonnegative(),
+  cache_creation_input_tokens: z.z.number().int().nonnegative().optional(),
+  cache_read_input_tokens: z.z.number().int().nonnegative().optional(),
+  output_tokens: z.z.number().int().nonnegative(),
+  service_tier: z.z.string().optional()
+});
+const TextContentSchema = z.z.object({
+  type: z.z.literal("text"),
+  text: z.z.string()
+});
+const ThinkingContentSchema = z.z.object({
+  type: z.z.literal("thinking"),
+  thinking: z.z.string(),
+  signature: z.z.string()
+});
+const ToolUseContentSchema = z.z.object({
+  type: z.z.literal("tool_use"),
+  id: z.z.string(),
+  name: z.z.string(),
+  input: z.z.unknown()
+  // Tool-specific input parameters
+});
+const ToolResultContentSchema = z.z.object({
+  tool_use_id: z.z.string(),
+  type: z.z.literal("tool_result"),
+  content: z.z.union([
+    z.z.string(),
+    // For simple string responses
+    z.z.array(TextContentSchema)
+    // For structured content blocks (typically text)
+  ]),
+  is_error: z.z.boolean().optional()
+});
+const ContentSchema = z.z.union([
+  TextContentSchema,
+  ThinkingContentSchema,
+  ToolUseContentSchema,
+  ToolResultContentSchema
+]);
+const UserMessageSchema = z.z.object({
+  role: z.z.literal("user"),
+  content: z.z.union([
+    z.z.string(),
+    // Simple string content
+    z.z.array(z.z.union([ToolResultContentSchema, TextContentSchema]))
+  ])
+});
+const AssistantMessageSchema = z.z.object({
+  id: z.z.string(),
+  type: z.z.literal("message"),
+  role: z.z.literal("assistant"),
+  model: z.z.string(),
+  content: z.z.array(ContentSchema),
+  stop_reason: z.z.string().nullable(),
+  stop_sequence: z.z.string().nullable(),
+  usage: UsageSchema
+});
+const BaseEntrySchema = z.z.object({
+  cwd: z.z.string(),
+  sessionId: z.z.string(),
+  version: z.z.string(),
+  uuid: z.z.string(),
+  timestamp: z.z.string().datetime(),
+  parent_tool_use_id: z.z.string().nullable().optional()
+});
+const SummaryEntrySchema = z.z.object({
+  type: z.z.literal("summary"),
+  summary: z.z.string(),
+  leafUuid: z.z.string()
+});
+const UserEntrySchema = BaseEntrySchema.extend({
+  type: z.z.literal("user"),
+  message: UserMessageSchema,
+  isMeta: z.z.boolean().optional(),
+  toolUseResult: z.z.unknown().optional()
+  // Present when user responds to tool use
+});
+const AssistantEntrySchema = BaseEntrySchema.extend({
+  type: z.z.literal("assistant"),
+  message: AssistantMessageSchema,
+  requestId: z.z.string().optional()
+});
+const SystemEntrySchema = BaseEntrySchema.extend({
+  type: z.z.literal("system"),
+  content: z.z.string(),
+  isMeta: z.z.boolean().optional(),
+  level: z.z.string().optional(),
+  parentUuid: z.z.string().optional(),
+  isSidechain: z.z.boolean().optional(),
+  userType: z.z.string().optional()
+});
+const RawJSONLinesSchema = z.z.discriminatedUnion("type", [
+  UserEntrySchema,
+  AssistantEntrySchema,
+  SummaryEntrySchema,
+  SystemEntrySchema
+]);
+
+function createSessionScanner(opts) {
+  const projectName = node_path.resolve(opts.workingDirectory).replace(/\//g, "-");
+  const projectDir = node_path.join(os.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 = node_path.join(projectDir, `${sessionId}.jsonl`);
+      let file;
+      try {
+        file = await promises.readFile(expectedSessionFile, "utf-8");
+      } catch (error) {
+        return;
+      }
+      let lines = file.split("\n");
+      for (let l of lines) {
+        try {
+          let message = JSON.parse(l);
+          let parsed = RawJSONLinesSchema.safeParse(message);
+          if (!parsed.success) {
+            logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
+            continue;
           }
+          let key = getMessageKey(parsed.data);
+          if (processedMessages.has(key)) {
+            continue;
+          }
+          processedMessages.add(key);
+          logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
+          logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
+          opts.onMessage(parsed.data);
+        } catch (e) {
+          continue;
+        }
+      }
+    };
+    for (let session of sessions) {
+      await processSessionFile(session);
+    }
+    for (let p of sessions) {
+      if (pendingSessions.has(p)) {
+        pendingSessions.delete(p);
+        finishedSessions.add(p);
+      }
+    }
+    currentSessionWatcherAbortController?.abort();
+    currentSessionWatcherAbortController = new AbortController();
+    void (async () => {
+      if (currentSessionId) {
+        const sessionFile = node_path.join(projectDir, `${currentSessionId}.jsonl`);
+        try {
+          for await (const change of promises.watch(sessionFile, { persistent: true, signal: currentSessionWatcherAbortController.signal })) {
+            await processSessionFile(currentSessionId);
+          }
+        } catch (error) {
+          if (error.name !== "AbortError") {
+            logger.debug(`[SESSION_SCANNER] Watch error: ${error.message}`);
+          }
+        }
+      }
+    })();
+  });
+  const intervalId = setInterval(() => {
+    sync.invalidate();
+  }, 3e3);
+  return {
+    refresh: () => sync.invalidate(),
+    cleanup: () => {
+      clearInterval(intervalId);
+      currentSessionWatcherAbortController?.abort();
+    },
+    onNewSession: (sessionId) => {
+      if (currentSessionId === sessionId) {
+        return;
+      }
+      if (finishedSessions.has(sessionId)) {
+        return;
+      }
+      if (pendingSessions.has(sessionId)) {
+        return;
+      }
+      if (currentSessionId) {
+        pendingSessions.add(currentSessionId);
+      }
+      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;
         }
       }
-      await new Promise((resolve) => {
-        messageResolve = resolve;
+      opts.session.sendClaudeSessionMessage(message);
+    }
+  });
+  let onSessionFound = (newSessionId) => {
+    sessionId = newSessionId;
+    sessionScanner.onNewSession(newSessionId);
+  };
+  while (true) {
+    if (currentMessageQueue.size() > 0) {
+      mode = "remote";
+      continue;
+    }
+    if (mode === "interactive") {
+      let abortedOutside = false;
+      const interactiveAbortController = new AbortController();
+      opts.session.setHandler("switch", () => {
+        if (!interactiveAbortController.signal.aborted) {
+          abortedOutside = true;
+          mode = "remote";
+          interactiveAbortController.abort();
+        }
+      });
+      onMessage = () => {
+        if (!interactiveAbortController.signal.aborted) {
+          abortedOutside = true;
+          mode = "remote";
+          interactiveAbortController.abort();
+        }
+        onMessage = null;
+      };
+      await claudeLocal({
+        path: opts.path,
+        sessionId,
+        onSessionFound,
+        abort: interactiveAbortController.signal
       });
+      onMessage = null;
+      if (!abortedOutside) {
+        return;
+      }
+      if (mode !== "interactive") {
+        console.log("Switching to remote mode...");
+      }
+    }
+    if (mode === "remote") {
+      logger.debug("Starting " + sessionId);
+      const remoteAbortController = new AbortController();
+      opts.session.setHandler("abort", () => {
+        if (!remoteAbortController.signal.aborted) {
+          remoteAbortController.abort();
+        }
+      });
+      const abortHandler = () => {
+        if (!remoteAbortController.signal.aborted) {
+          mode = "interactive";
+          remoteAbortController.abort();
+        }
+        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...");
+      }
+    }
+  }
+}
+
+async function startPermissionServerV2(handler) {
+  const mcp = new mcp_js.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.z.string().describe("The tool that needs permission"),
+      input: z.z.any().describe("The arguments for the tool")
     }
-  })();
-  return async () => {
-    exiting = true;
-    if (messageResolve) {
-      messageResolve();
+    // outputSchema: {
+    //     approved: z.boolean().describe('Whether the tool was approved'),
+    //     reason: z.string().describe('The reason for the approval or denial'),
+    // },
+  }, async (args) => {
+    const response = await handler({ name: args.tool_name, arguments: args.input });
+    const result = response.approved ? { behavior: "allow", updatedInput: args.input || {} } : { behavior: "deny", message: response.reason || "Permission denied by user" };
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result)
+        }
+      ],
+      isError: false
+    };
+  });
+  const transport = new streamableHttp_js.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 = node_http.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();
+      }
     }
-    await promise;
+  });
+  const baseUrl = await new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      resolve(new URL(`http://127.0.0.1:${addr.port}`));
+    });
+  });
+  return {
+    url: baseUrl.toString(),
+    toolName: "ask_permission"
   };
 }
 
-async function start(options = {}) {
+class InterruptController {
+  interruptFn;
+  isInterrupting = false;
+  /**
+   * Register an interrupt function from claudeRemote
+   */
+  register(fn) {
+    this.interruptFn = fn;
+  }
+  /**
+   * Unregister the interrupt function (cleanup)
+   */
+  unregister() {
+    this.interruptFn = void 0;
+    this.isInterrupting = false;
+  }
+  /**
+   * Trigger the interrupt - can be called from anywhere
+   */
+  async interrupt() {
+    if (!this.interruptFn || this.isInterrupting) {
+      return false;
+    }
+    this.isInterrupting = true;
+    try {
+      await this.interruptFn();
+      return true;
+    } catch (error) {
+      logger.debug("Failed to interrupt Claude:", error);
+      return false;
+    } finally {
+      this.isInterrupting = false;
+    }
+  }
+  /**
+   * Check if interrupt is available
+   */
+  canInterrupt() {
+    return !!this.interruptFn && !this.isInterrupting;
+  }
+}
+
+async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
-  const projectName = node_path.basename(workingDirectory);
   const sessionTag = node_crypto.randomUUID();
-  logger.info(`Starting happy session for project: ${projectName}`);
-  const secret = await getOrCreateSecretKey();
-  logger.info("Secret key loaded");
-  const token = await authGetToken(secret);
-  logger.info("Authenticated with handy server");
-  const api = new ApiClient(token, secret);
-  const response = await api.getOrCreateSession({ tag: sessionTag, metadata: { path: workingDirectory, host: os.hostname() } });
-  logger.info(`Session created: ${response.session.id}`);
-  const handyUrl = generateAppUrl(secret);
-  displayQRCode(handyUrl);
-  const session = api.session(response.session.id);
-  const loopDestroy = startClaudeLoop({ path: workingDirectory }, session);
-  const shutdown = async () => {
-    logger.info("Shutting down...");
-    await loopDestroy();
-    await session.close();
-    process.exit(0);
+  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.debug(`Session created: ${response.id}`);
+  const session = api.session(response);
+  const pushClient = api.push();
+  const interruptController = new InterruptController();
+  let requests = /* @__PURE__ */ new Map();
+  const permissionServer = await startPermissionServerV2(async (request) => {
+    const id = node_crypto.randomUUID();
+    let promise = new Promise((resolve) => {
+      requests.set(id, resolve);
+    });
+    let timeout = setTimeout(async () => {
+      logger.info("Permission timeout - attempting to interrupt Claude");
+      const interrupted = await interruptController.interrupt();
+      if (interrupted) {
+        logger.info("Claude interrupted successfully");
+      }
+      requests.delete(id);
+      session.updateAgentState((currentState) => {
+        let r = { ...currentState.requests };
+        delete r[id];
+        return {
+          ...currentState,
+          requests: r
+        };
+      });
+    }, 1e3 * 60 * 4.5);
+    logger.info("Permission request" + id + " " + JSON.stringify(request));
+    try {
+      await pushClient.sendToAllDevices(
+        "Permission Request",
+        `Claude wants to use ${request.name}`,
+        {
+          sessionId: response.id,
+          requestId: id,
+          tool: request.name,
+          type: "permission_request"
+        }
+      );
+      logger.info("Push notification sent for permission request");
+    } catch (error) {
+      logger.debug("Failed to send push notification:", error);
+    }
+    session.updateAgentState((currentState) => ({
+      ...currentState,
+      requests: {
+        ...currentState.requests,
+        [id]: {
+          tool: request.name,
+          arguments: request.arguments
+        }
+      }
+    }));
+    promise.then(() => clearTimeout(timeout)).catch(() => clearTimeout(timeout));
+    return promise;
+  });
+  session.setHandler("permission", (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();
+  });
+  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);
+    }
   };
-  process.on("SIGINT", shutdown);
-  process.on("SIGTERM", shutdown);
-  logger.info("Happy CLI is running. Press Ctrl+C to stop.");
-  await new Promise(() => {
+  await loop({
+    path: workingDirectory,
+    model: options.model,
+    permissionMode: options.permissionMode,
+    mcpServers: {
+      "permission": {
+        type: "http",
+        url: permissionServer.url
+      }
+    },
+    permissionPromptToolName: "mcp__permission__" + permissionServer.toolName,
+    onThinking: (t) => {
+      thinking = t;
+      session.keepAlive(t);
+    },
+    session,
+    onAssistantResult,
+    interruptController
   });
+  clearInterval(pingInterval);
+  process.exit(0);
 }
 
-const args = process.argv.slice(2);
-const options = {};
-let showHelp = false;
-let showVersion = false;
-for (let i = 0; i < args.length; i++) {
-  const arg = args[i];
-  if (arg === "-h" || arg === "--help") {
-    showHelp = true;
-  } else if (arg === "-v" || arg === "--version") {
-    showVersion = true;
-  } else if (arg === "-m" || arg === "--model") {
-    options.model = args[++i];
-  } else if (arg === "-p" || arg === "--permission-mode") {
-    options.permissionMode = args[++i];
-  } else {
-    console.error(chalk.red(`Unknown argument: ${arg}`));
-    process.exit(1);
+const credentialsSchema = z__namespace.object({
+  secret: z__namespace.string().base64(),
+  token: z__namespace.string()
+});
+async function readCredentials() {
+  if (!node_fs.existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await promises.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 (!node_fs.existsSync(configuration.happyDir)) {
+    await promises.mkdir(configuration.happyDir, { recursive: true });
+  }
+  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token
+  }, null, 2));
+}
+
+function displayQRCode(url) {
+  console.log("=".repeat(80));
+  console.log("\u{1F4F1} To authenticate, scan this QR code with your mobile device:");
+  console.log("=".repeat(80));
+  qrcode.generate(url, { small: true }, (qr) => {
+    for (let l of qr.split("\n")) {
+      console.log(" ".repeat(10) + l);
+    }
+  });
+  console.log("=".repeat(80));
+}
+
+async function doAuth() {
+  console.log("Starting authentication...");
+  const secret = new Uint8Array(node_crypto.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);
+  }
+  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;
 }
-if (showHelp) {
-  console.log(`
+
+(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 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
@@ -588,21 +1945,68 @@ ${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 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);
+    }
+    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);
+    }
   }
-  process.exit(1);
-});
+})();
+async function cleanKey() {
+  const happyDir = configuration.happyDir;
+  if (!node_fs.existsSync(happyDir)) {
+    console.log(chalk.yellow("No happy data directory found at:"), happyDir);
+    return;
+  }
+  console.log(chalk.blue("Found happy data directory at:"), happyDir);
+  console.log(chalk.yellow("\u26A0\uFE0F  This will remove all authentication data and require reconnecting your phone."));
+  const rl = node_readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const answer = await new Promise((resolve) => {
+    rl.question(chalk.yellow("Are you sure you want to remove the happy data directory? (y/N): "), resolve);
+  });
+  rl.close();
+  if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+    try {
+      node_fs.rmSync(happyDir, { recursive: true, force: true });
+      console.log(chalk.green("\u2713 Happy data directory removed successfully"));
+      console.log(chalk.blue("\u2139\uFE0F  You will need to reconnect your phone on the next session"));
+    } catch (error) {
+      throw new Error(`Failed to remove data directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  } else {
+    console.log(chalk.blue("Operation cancelled"));
+  }
+}