happy-coder 0.1.7 → 0.1.10

package/dist/index.cjs

@@ -1,740 +1,58 @@
 'use strict';
 
 var chalk = require('chalk');
-var axios = require('axios');
-var fs = require('fs');
-var os = require('node:os');
-var node_path = require('node:path');
-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 z = require('zod');
+var types = require('./types-B2JzqUiU.cjs');
 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_fs = require('node:fs');
+var os = require('node:os');
+var node_path = require('node:path');
 var node_child_process = require('node:child_process');
 var node_readline = require('node:readline');
 var node_url = require('node:url');
+var promises = require('node:fs/promises');
 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 z = require('zod');
+var node_https = require('node:https');
+var net = require('node:net');
+var child_process = require('child_process');
+var util = require('util');
+var promises$1 = require('fs/promises');
+var crypto = require('crypto');
+var path = require('path');
+var tweetnacl = require('tweetnacl');
+var axios = require('axios');
 var qrcode = require('qrcode-terminal');
+var node_events = require('node:events');
+var socket_ioClient = require('socket.io-client');
+var os$1 = require('os');
+var fs = require('fs');
+require('expo-server-sdk');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 function _interopNamespaceDefault(e) {
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
+    var n = Object.create(null);
+    if (e) {
+        Object.keys(e).forEach(function (k) {
+            if (k !== 'default') {
+                var d = Object.getOwnPropertyDescriptor(e, k);
+                Object.defineProperty(n, k, d.get ? d : {
+                    enumerable: true,
+                    get: function () { return e[k]; }
+                });
+            }
         });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
-
-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");
-  }
-}
-let configuration = void 0;
-function initializeConfiguration(location) {
-  configuration = new Configuration(location);
-}
-
-async function getSessionLogPath() {
-  if (!node_fs.existsSync(configuration.logsDir)) {
-    await promises.mkdir(configuration.logsDir, { recursive: true });
-  }
-  const now = /* @__PURE__ */ new Date();
-  const timestamp = now.toLocaleString("sv-SE", {
-    timeZone: Intl.DateTimeFormat().resolvedOptions().timeZone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit",
-    hour: "2-digit",
-    minute: "2-digit",
-    second: "2-digit"
-  }).replace(/[: ]/g, "-").replace(/,/g, "");
-  return node_path.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(`[${this.localTimezoneTimestamp()}]`, 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);
-  }
-  info(message, ...args) {
-    this.logToConsole("info", "", message, ...args);
-    this.debug(message, args);
-  }
-  logToConsole(level, prefix, message, ...args) {
-    switch (level) {
-      case "debug": {
-        console.log(chalk.gray(prefix), message, ...args);
-        break;
-      }
-      case "error": {
-        console.error(chalk.red(prefix), message, ...args);
-        break;
-      }
-      case "info": {
-        console.log(chalk.blue(prefix), message, ...args);
-        break;
-      }
-      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 SessionMessageContentSchema = z.z.object({
-  c: z.z.string(),
-  // Base64 encoded encrypted content
-  t: z.z.literal("encrypted")
-});
-const UpdateBodySchema = z.z.object({
-  message: z.z.object({
-    id: z.z.string(),
-    seq: z.z.number(),
-    content: SessionMessageContentSchema
-  }),
-  sid: z.z.string(),
-  // Session ID
-  t: z.z.literal("new-message")
-});
-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()
-});
-z.z.object({
-  id: z.z.string(),
-  seq: z.z.number(),
-  body: z.z.union([UpdateBodySchema, UpdateSessionBodySchema]),
-  createdAt: z.z.number()
-});
-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: z.z.number(),
-  id: z.z.string(),
-  seq: z.z.number(),
-  updatedAt: z.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$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 = z.z.object({
-  role: z.z.literal("agent"),
-  content: z.z.object({
-    type: z.z.literal("output"),
-    data: z.z.any()
-  })
-});
-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;
-  pendingMessages = [];
-  pendingMessageCallback = null;
-  rpcHandlers = /* @__PURE__ */ new Map();
-  constructor(token, secret, session) {
-    super();
-    this.token = token;
-    this.secret = secret;
-    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,
-        clientType: "session-scoped",
-        sessionId: this.sessionId
-      },
-      path: "/v1/updates",
-      reconnection: true,
-      reconnectionAttempts: Infinity,
-      reconnectionDelay: 1e3,
-      reconnectionDelayMax: 5e3,
-      transports: ["websocket"],
-      withCredentials: true,
-      autoConnect: false
-    });
-    this.socket.on("connect", () => {
-      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.debug("[API] Socket disconnected:", reason);
-    });
-    this.socket.on("connect_error", (error) => {
-      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$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) {
-    this.pendingMessageCallback = callback;
-    while (this.pendingMessages.length > 0) {
-      callback(this.pendingMessages.shift());
-    }
-  }
-  /**
-   * Send message to session
-   * @param body - Message body (can be MessageContent or raw content for agent messages)
-   */
-  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);
-  }
+    n.default = e;
+    return Object.freeze(n);
 }
 
-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
-   */
-  async getOrCreateSession(opts) {
-    try {
-      const response = await axios.post(
-        `${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}`,
-            "Content-Type": "application/json"
-          }
-        }
-      );
-      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.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"}`);
-    }
-  }
-  /**
-   * Start realtime session client
-   * @param id - Session ID
-   * @returns Session client
-   */
-  session(session) {
-    return new ApiSessionClient(this.token, this.secret, session);
-  }
-  /**
-   * Get push notification client
-   * @returns Push notification client
-   */
-  push() {
-    return this.pushClient;
-  }
-}
+var z__namespace = /*#__PURE__*/_interopNamespaceDefault(z);
 
 function formatClaudeMessage(message, onAssistantResult) {
-  logger.debugLargeJson("[CLAUDE] Message from non interactive & remote mode:", message);
+  types.logger.debugLargeJson("[CLAUDE] Message from non interactive & remote mode:", message);
   switch (message.type) {
     case "system": {
       const sysMsg = message;
@@ -827,7 +145,7 @@ function formatClaudeMessage(message, onAssistantResult) {
           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);
+              types.logger.debug("Error in onAssistantResult callback:", err);
             });
           }
         }
@@ -837,7 +155,7 @@ function formatClaudeMessage(message, onAssistantResult) {
       } 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);
+        types.logger.debugLargeJson("[RESULT] Error during execution", resultMsg);
       }
       break;
     }
@@ -859,7 +177,7 @@ function claudeCheckSession(sessionId, path) {
   const sessionFile = node_path.join(projectDir, `${sessionId}.jsonl`);
   const sessionExists = node_fs.existsSync(sessionFile);
   if (!sessionExists) {
-    logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
+    types.logger.debug(`[claudeCheckSession] Path ${sessionFile} does not exist`);
     return false;
   }
   const sessionData = node_fs.readFileSync(sessionFile, "utf-8").split("\n");
@@ -905,7 +223,7 @@ async function claudeRemote(opts) {
       }
     }
   });
-  logger.debug(`[claudeRemote] Starting query with messages`);
+  types.logger.debug(`[claudeRemote] Starting query with messages`);
   response = claudeCode.query({
     prompt: opts.messages,
     abortController,
@@ -913,15 +231,15 @@ async function claudeRemote(opts) {
   });
   if (opts.interruptController) {
     opts.interruptController.register(async () => {
-      logger.debug("[claudeRemote] Interrupting Claude via SDK");
+      types.logger.debug("[claudeRemote] Interrupting Claude via SDK");
       await response.interrupt();
     });
   }
   printDivider();
   try {
-    logger.debug(`[claudeRemote] Starting to iterate over response`);
+    types.logger.debug(`[claudeRemote] Starting to iterate over response`);
     for await (const message of response) {
-      logger.debug(`[claudeRemote] Received message from SDK: ${message.type}`);
+      types.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, "-");
@@ -935,13 +253,13 @@ async function claudeRemote(opts) {
         });
       }
     }
-    logger.debug(`[claudeRemote] Finished iterating over response`);
+    types.logger.debug(`[claudeRemote] Finished iterating over response`);
   } catch (e) {
     if (abortController.signal.aborted) {
-      logger.debug(`[claudeRemote] Aborted`);
+      types.logger.debug(`[claudeRemote] Aborted`);
     }
     if (e instanceof claudeCode.AbortError) {
-      logger.debug(`[claudeRemote] Aborted`);
+      types.logger.debug(`[claudeRemote] Aborted`);
     } else {
       throw e;
     }
@@ -951,7 +269,7 @@ async function claudeRemote(opts) {
     }
   }
   printDivider();
-  logger.debug(`[claudeRemote] Function completed`);
+  types.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))));
@@ -965,7 +283,7 @@ async function claudeLocal(opts) {
   const detectedIdsFileSystem = /* @__PURE__ */ new Set();
   watcher.on("change", (event, filename) => {
     if (typeof filename === "string" && filename.toLowerCase().endsWith(".jsonl")) {
-      logger.debug("change", event, filename);
+      types.logger.debug("change", event, filename);
       const sessionId = filename.replace(".jsonl", "");
       if (detectedIdsFileSystem.has(sessionId)) {
         return;
@@ -1056,10 +374,10 @@ class MessageQueue {
     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}`);
+    types.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}"`);
+      types.logger.debug(`[MessageQueue] Found waiter! Delivering message directly: "${message}"`);
       waiter({
         type: "user",
         message: {
@@ -1070,7 +388,7 @@ class MessageQueue {
         session_id: ""
       });
     } else {
-      logger.debug(`[MessageQueue] No waiter found. Adding to queue: "${message}"`);
+      types.logger.debug(`[MessageQueue] No waiter found. Adding to queue: "${message}"`);
       this.queue.push({
         type: "user",
         message: {
@@ -1081,13 +399,13 @@ class MessageQueue {
         session_id: ""
       });
     }
-    logger.debug(`[MessageQueue] push() completed. Waiters: ${this.waiters.length}, Queue size after: ${this.queue.length}`);
+    types.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}`);
+    types.logger.debug(`[MessageQueue] close() called. Waiters: ${this.waiters.length}`);
     this.closed = true;
     this.closeResolve?.();
   }
@@ -1107,25 +425,25 @@ class MessageQueue {
    * Async iterator implementation
    */
   async *[Symbol.asyncIterator]() {
-    logger.debug(`[MessageQueue] Iterator started`);
+    types.logger.debug(`[MessageQueue] Iterator started`);
     while (true) {
       const message = this.queue.shift();
       if (message !== void 0) {
-        logger.debug(`[MessageQueue] Iterator yielding queued message`);
+        types.logger.debug(`[MessageQueue] Iterator yielding queued message`);
         yield message;
         continue;
       }
       if (this.closed) {
-        logger.debug(`[MessageQueue] Iterator ending - queue closed`);
+        types.logger.debug(`[MessageQueue] Iterator ending - queue closed`);
         return;
       }
-      logger.debug(`[MessageQueue] Iterator waiting for next message...`);
+      types.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`);
+        types.logger.debug(`[MessageQueue] Iterator ending - no more messages`);
         return;
       }
-      logger.debug(`[MessageQueue] Iterator yielding waited message`);
+      types.logger.debug(`[MessageQueue] Iterator yielding waited message`);
       yield nextMessage;
     }
   }
@@ -1135,18 +453,18 @@ class MessageQueue {
   waitForNext() {
     return new Promise((resolve) => {
       if (this.closed) {
-        logger.debug(`[MessageQueue] waitForNext() called but queue is closed`);
+        types.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}`);
+      types.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}`);
+          types.logger.debug(`[MessageQueue] waitForNext() waiter removed due to close. Remaining waiters: ${this.waiters.length}`);
           resolve(void 0);
         }
       });
@@ -1200,7 +518,7 @@ class InvalidateSync {
     this._pendings = [];
   };
   _doSync = async () => {
-    await backoff(async () => {
+    await types.backoff(async () => {
       if (this._stopped) {
         return;
       }
@@ -1220,105 +538,6 @@ class InvalidateSync {
   };
 }
 
-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);
@@ -1327,6 +546,7 @@ function createSessionScanner(opts) {
   let currentSessionId = null;
   let currentSessionWatcherAbortController = null;
   let processedMessages = /* @__PURE__ */ new Set();
+  let seenRemoteUserMessageCounters = /* @__PURE__ */ new Map();
   const sync = new InvalidateSync(async () => {
     let sessions = [];
     for (let p of pendingSessions) {
@@ -1347,9 +567,9 @@ function createSessionScanner(opts) {
       for (let l of lines) {
         try {
           let message = JSON.parse(l);
-          let parsed = RawJSONLinesSchema.safeParse(message);
+          let parsed = types.RawJSONLinesSchema.safeParse(message);
           if (!parsed.success) {
-            logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
+            types.logger.debugLargeJson(`[SESSION_SCANNER] Failed to parse message`, message);
             continue;
           }
           let key = getMessageKey(parsed.data);
@@ -1357,9 +577,16 @@ function createSessionScanner(opts) {
             continue;
           }
           processedMessages.add(key);
-          logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
-          logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
-          opts.onMessage(parsed.data);
+          types.logger.debugLargeJson(`[SESSION_SCANNER] Processing message`, parsed.data);
+          types.logger.debug(`[SESSION_SCANNER] Message key (new): ${key}`);
+          if (parsed.data.type === "user" && typeof parsed.data.message.content === "string" && parsed.data.isSidechain !== true && parsed.data.isMeta !== true) {
+            const currentCounter = seenRemoteUserMessageCounters.get(parsed.data.message.content);
+            if (currentCounter && currentCounter > 0) {
+              seenRemoteUserMessageCounters.set(parsed.data.message.content, currentCounter - 1);
+              continue;
+            }
+          }
+          opts.onMessage(message);
         } catch (e) {
           continue;
         }
@@ -1385,7 +612,7 @@ function createSessionScanner(opts) {
           }
         } catch (error) {
           if (error.name !== "AbortError") {
-            logger.debug(`[SESSION_SCANNER] Watch error: ${error.message}`);
+            types.logger.debug(`[SESSION_SCANNER] Watch error: ${error.message}`);
           }
         }
       }
@@ -1413,8 +640,12 @@ function createSessionScanner(opts) {
       if (currentSessionId) {
         pendingSessions.add(currentSessionId);
       }
+      types.logger.debug(`[SESSION_SCANNER] New session: ${sessionId}`);
       currentSessionId = sessionId;
       sync.invalidate();
+    },
+    onRemoteUserMessageForDeduplication: (messageContent) => {
+      seenRemoteUserMessageCounters.set(messageContent, (seenRemoteUserMessageCounters.get(messageContent) || 0) + 1);
     }
   };
 }
@@ -1448,32 +679,24 @@ function sortKeys(value) {
 }
 
 async function loop(opts) {
-  let mode = "interactive";
+  let mode = opts.startingMode ?? "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;
-        }
-      }
       opts.session.sendClaudeSessionMessage(message);
     }
   });
+  opts.session.onUserMessage((message) => {
+    sessionScanner.onRemoteUserMessageForDeduplication(message.content.text);
+    currentMessageQueue.push(message.content.text);
+    types.logger.debugLargeJson("User message pushed to queue:", message);
+    if (onMessage) {
+      onMessage();
+    }
+  });
   let onSessionFound = (newSessionId) => {
     sessionId = newSessionId;
     sessionScanner.onNewSession(newSessionId);
@@ -1516,7 +739,7 @@ async function loop(opts) {
       }
     }
     if (mode === "remote") {
-      logger.debug("Starting " + sessionId);
+      types.logger.debug("Starting " + sessionId);
       const remoteAbortController = new AbortController();
       opts.session.setHandler("abort", () => {
         if (!remoteAbortController.signal.aborted) {
@@ -1528,14 +751,18 @@ async function loop(opts) {
           mode = "interactive";
           remoteAbortController.abort();
         }
-        process.stdin.setRawMode(false);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
       };
       process.stdin.resume();
-      process.stdin.setRawMode(true);
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+      }
       process.stdin.setEncoding("utf8");
       process.stdin.on("data", abortHandler);
       try {
-        logger.debug(`Starting claudeRemote with messages: ${currentMessageQueue.size()}`);
+        types.logger.debug(`Starting claudeRemote with messages: ${currentMessageQueue.size()}`);
         await claudeRemote({
           abort: remoteAbortController.signal,
           sessionId,
@@ -1549,7 +776,9 @@ async function loop(opts) {
         });
       } finally {
         process.stdin.off("data", abortHandler);
-        process.stdin.setRawMode(false);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
         currentMessageQueue.close();
         currentMessageQueue = new MessageQueue();
       }
@@ -1600,7 +829,7 @@ async function startPermissionServerV2(handler) {
     try {
       await transport.handleRequest(req, res);
     } catch (error) {
-      logger.debug("Error handling request:", error);
+      types.logger.debug("Error handling request:", error);
       if (!res.headersSent) {
         res.writeHead(500).end();
       }
@@ -1646,7 +875,7 @@ class InterruptController {
       await this.interruptFn();
       return true;
     } catch (error) {
-      logger.debug("Failed to interrupt Claude:", error);
+      types.logger.debug("Failed to interrupt Claude:", error);
       return false;
     } finally {
       this.isInterrupting = false;
@@ -1660,16 +889,410 @@ class InterruptController {
   }
 }
 
+var version = "0.1.10";
+var packageJson = {
+	version: version};
+
+async function startAnthropicActivityProxy(onClaudeActivity) {
+  const requestTimeouts = /* @__PURE__ */ new Map();
+  let requestCounter = 0;
+  let idleTimer = null;
+  const maxTimeBeforeIdle = 50;
+  const requestTimeout = 5 * 60 * 1e3;
+  const cleanupRequest = (requestId, reason) => {
+    const timeout = requestTimeouts.get(requestId);
+    if (timeout) {
+      clearTimeout(timeout);
+      requestTimeouts.delete(requestId);
+      types.logger.debug(`[AnthropicProxy #${requestId}] Cleaned up (${reason}), active requests: ${requestTimeouts.size}`);
+      claudeDidSomeWork();
+    }
+  };
+  const claudeDidSomeWork = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    if (requestTimeouts.size === 0) {
+      idleTimer = setTimeout(() => {
+        types.logger.debug(`[AnthropicProxy] Idle for ${maxTimeBeforeIdle}ms, active requests: ${requestTimeouts.size}`);
+        onClaudeActivity("idle");
+      }, maxTimeBeforeIdle);
+    }
+  };
+  const server = node_http.createServer((req, res) => {
+    const requestId = ++requestCounter;
+    const isAnthropicRequest = req.headers.host === "api.anthropic.com" || req.url?.includes("anthropic.com");
+    if (isAnthropicRequest) {
+      const timeout = setTimeout(() => {
+        types.logger.debug(`[AnthropicProxy #${requestId}] Request timeout after ${requestTimeout}ms`);
+        cleanupRequest(requestId, "timeout");
+      }, requestTimeout);
+      requestTimeouts.set(requestId, timeout);
+      onClaudeActivity("working");
+      types.logger.debug(`[AnthropicProxy #${requestId}] Anthropic request: ${req.method} ${req.url}, active requests: ${requestTimeouts.size}`);
+    }
+    const chunks = [];
+    req.on("data", (chunk) => {
+      chunks.push(chunk);
+      if (isAnthropicRequest) {
+        claudeDidSomeWork();
+      }
+    });
+    req.on("end", () => {
+      const body = Buffer.concat(chunks);
+      let targetUrl;
+      if (isAnthropicRequest) {
+        targetUrl = new node_url.URL(req.url || "/", "https://api.anthropic.com");
+      } else {
+        const protocol = req.headers["x-forwarded-proto"] || "https";
+        const host = req.headers.host || "localhost";
+        targetUrl = new node_url.URL(req.url || "/", `${protocol}://${host}`);
+      }
+      const options = {
+        hostname: targetUrl.hostname,
+        port: targetUrl.port || (targetUrl.protocol === "https:" ? 443 : 80),
+        path: targetUrl.pathname + targetUrl.search,
+        method: req.method,
+        headers: {
+          ...req.headers,
+          host: targetUrl.hostname
+        }
+      };
+      const requestMethod = targetUrl.protocol === "https:" ? node_https.request : node_http.request;
+      const proxyReq = requestMethod(options, (proxyRes) => {
+        res.writeHead(proxyRes.statusCode || 200, proxyRes.headers);
+        proxyRes.pipe(res);
+        proxyRes.on("end", () => {
+          if (isAnthropicRequest) {
+            cleanupRequest(requestId, "completed");
+          }
+        });
+      });
+      proxyReq.on("error", (error) => {
+        if (isAnthropicRequest) {
+          cleanupRequest(requestId, `error: ${error.message}`);
+        } else {
+          types.logger.debug(`[AnthropicProxy #${requestId}] Error:`, error.message);
+        }
+        res.writeHead(502);
+        res.end("Bad Gateway");
+      });
+      if (body.length > 0) {
+        proxyReq.write(body);
+      }
+      proxyReq.end();
+    });
+  });
+  server.on("connect", (req, clientSocket, head) => {
+    const requestId = ++requestCounter;
+    const [hostname, port] = req.url?.split(":") || ["", "443"];
+    const isAnthropicRequest = hostname === "api.anthropic.com";
+    if (isAnthropicRequest) {
+      const timeout = setTimeout(() => {
+        types.logger.debug(`[AnthropicProxy #${requestId}] CONNECT timeout after ${requestTimeout}ms`);
+        cleanupRequest(requestId, "timeout");
+      }, requestTimeout);
+      requestTimeouts.set(requestId, timeout);
+      onClaudeActivity("working");
+      types.logger.debug(`[AnthropicProxy #${requestId}] CONNECT to api.anthropic.com, active requests: ${requestTimeouts.size}`);
+    }
+    const serverSocket = net.connect(parseInt(port) || 443, hostname, () => {
+      clientSocket.write("HTTP/1.1 200 Connection Established\r\n\r\n");
+      serverSocket.write(head);
+      serverSocket.pipe(clientSocket);
+      clientSocket.pipe(serverSocket);
+    });
+    const cleanup = () => {
+      if (isAnthropicRequest) {
+        cleanupRequest(requestId, "CONNECT closed");
+      }
+    };
+    serverSocket.on("error", (err) => {
+      types.logger.debug(`[AnthropicProxy #${requestId}] CONNECT error:`, err.message);
+      clientSocket.end();
+      cleanup();
+    });
+    clientSocket.on("error", cleanup);
+    clientSocket.on("end", cleanup);
+    serverSocket.on("end", cleanup);
+  });
+  const url = await new Promise((resolve) => {
+    server.listen(0, "127.0.0.1", () => {
+      const addr = server.address();
+      if (addr && typeof addr === "object") {
+        resolve(`http://127.0.0.1:${addr.port}`);
+      }
+    });
+  });
+  types.logger.debug(`[AnthropicProxy] Started at ${url}`);
+  return {
+    url,
+    cleanup: () => {
+      if (idleTimer) clearTimeout(idleTimer);
+      for (const [requestId, timeout] of requestTimeouts) {
+        clearTimeout(timeout);
+        types.logger.debug(`[AnthropicProxy] Cleaning up timeout for request #${requestId}`);
+      }
+      requestTimeouts.clear();
+      if (requestTimeouts.size > 0) {
+        types.logger.debug(`[AnthropicProxy] Warning: ${requestTimeouts.size} active requests still pending at cleanup:`, Array.from(requestTimeouts.keys()));
+      }
+      server.close();
+    }
+  };
+}
+
+const execAsync = util.promisify(child_process.exec);
+function registerHandlers(session, interruptController, permissionCallbacks) {
+  session.setHandler("abort", async () => {
+    types.logger.info("Abort request - interrupting Claude");
+    await interruptController.interrupt();
+  });
+  if (permissionCallbacks) {
+    session.setHandler("permission", async (message) => {
+      types.logger.info("Permission response" + JSON.stringify(message));
+      const id = message.id;
+      const resolve = permissionCallbacks.requests.get(id);
+      if (resolve) {
+        if (!message.approved) {
+          types.logger.debug("Permission denied, interrupting Claude");
+          await interruptController.interrupt();
+        }
+        resolve({ approved: message.approved, reason: message.reason });
+        permissionCallbacks.requests.delete(id);
+      } else {
+        types.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("bash", async (data) => {
+    types.logger.info("Shell command request:", data.command);
+    try {
+      const options = {
+        cwd: data.cwd,
+        timeout: data.timeout || 3e4
+        // Default 30 seconds timeout
+      };
+      const { stdout, stderr } = await execAsync(data.command, options);
+      return {
+        success: true,
+        stdout: stdout || "",
+        stderr: stderr || "",
+        exitCode: 0
+      };
+    } catch (error) {
+      const execError = error;
+      if (execError.code === "ETIMEDOUT" || execError.killed) {
+        return {
+          success: false,
+          stdout: execError.stdout || "",
+          stderr: execError.stderr || "",
+          exitCode: typeof execError.code === "number" ? execError.code : -1,
+          error: "Command timed out"
+        };
+      }
+      return {
+        success: false,
+        stdout: execError.stdout || "",
+        stderr: execError.stderr || execError.message || "Command failed",
+        exitCode: typeof execError.code === "number" ? execError.code : 1,
+        error: execError.message || "Command failed"
+      };
+    }
+  });
+  session.setHandler("readFile", async (data) => {
+    types.logger.info("Read file request:", data.path);
+    try {
+      const buffer = await promises$1.readFile(data.path);
+      const content = buffer.toString("base64");
+      return { success: true, content };
+    } catch (error) {
+      types.logger.debug("Failed to read file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to read file" };
+    }
+  });
+  session.setHandler("writeFile", async (data) => {
+    types.logger.info("Write file request:", data.path);
+    try {
+      if (data.expectedHash !== null && data.expectedHash !== void 0) {
+        try {
+          const existingBuffer = await promises$1.readFile(data.path);
+          const existingHash = crypto.createHash("sha256").update(existingBuffer).digest("hex");
+          if (existingHash !== data.expectedHash) {
+            return {
+              success: false,
+              error: `File hash mismatch. Expected: ${data.expectedHash}, Actual: ${existingHash}`
+            };
+          }
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+          return {
+            success: false,
+            error: "File does not exist but hash was provided"
+          };
+        }
+      } else {
+        try {
+          await promises$1.stat(data.path);
+          return {
+            success: false,
+            error: "File already exists but was expected to be new"
+          };
+        } catch (error) {
+          const nodeError = error;
+          if (nodeError.code !== "ENOENT") {
+            throw error;
+          }
+        }
+      }
+      const buffer = Buffer.from(data.content, "base64");
+      await promises$1.writeFile(data.path, buffer);
+      const hash = crypto.createHash("sha256").update(buffer).digest("hex");
+      return { success: true, hash };
+    } catch (error) {
+      types.logger.debug("Failed to write file:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to write file" };
+    }
+  });
+  session.setHandler("listDirectory", async (data) => {
+    types.logger.info("List directory request:", data.path);
+    try {
+      const entries = await promises$1.readdir(data.path, { withFileTypes: true });
+      const directoryEntries = await Promise.all(
+        entries.map(async (entry) => {
+          const fullPath = path.join(data.path, entry.name);
+          let type = "other";
+          let size;
+          let modified;
+          if (entry.isDirectory()) {
+            type = "directory";
+          } else if (entry.isFile()) {
+            type = "file";
+          }
+          try {
+            const stats = await promises$1.stat(fullPath);
+            size = stats.size;
+            modified = stats.mtime.getTime();
+          } catch (error) {
+            types.logger.debug(`Failed to stat ${fullPath}:`, error);
+          }
+          return {
+            name: entry.name,
+            type,
+            size,
+            modified
+          };
+        })
+      );
+      directoryEntries.sort((a, b) => {
+        if (a.type === "directory" && b.type !== "directory") return -1;
+        if (a.type !== "directory" && b.type === "directory") return 1;
+        return a.name.localeCompare(b.name);
+      });
+      return { success: true, entries: directoryEntries };
+    } catch (error) {
+      types.logger.debug("Failed to list directory:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to list directory" };
+    }
+  });
+  session.setHandler("getDirectoryTree", async (data) => {
+    types.logger.info("Get directory tree request:", data.path, "maxDepth:", data.maxDepth);
+    async function buildTree(path$1, name, currentDepth) {
+      try {
+        const stats = await promises$1.stat(path$1);
+        const node = {
+          name,
+          path: path$1,
+          type: stats.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.getTime()
+        };
+        if (stats.isDirectory() && currentDepth < data.maxDepth) {
+          const entries = await promises$1.readdir(path$1, { withFileTypes: true });
+          const children = [];
+          await Promise.all(
+            entries.map(async (entry) => {
+              if (entry.isSymbolicLink()) {
+                types.logger.debug(`Skipping symlink: ${path.join(path$1, entry.name)}`);
+                return;
+              }
+              const childPath = path.join(path$1, entry.name);
+              const childNode = await buildTree(childPath, entry.name, currentDepth + 1);
+              if (childNode) {
+                children.push(childNode);
+              }
+            })
+          );
+          children.sort((a, b) => {
+            if (a.type === "directory" && b.type !== "directory") return -1;
+            if (a.type !== "directory" && b.type === "directory") return 1;
+            return a.name.localeCompare(b.name);
+          });
+          node.children = children;
+        }
+        return node;
+      } catch (error) {
+        types.logger.debug(`Failed to process ${path$1}:`, error instanceof Error ? error.message : String(error));
+        return null;
+      }
+    }
+    try {
+      if (data.maxDepth < 0) {
+        return { success: false, error: "maxDepth must be non-negative" };
+      }
+      const baseName = data.path === "/" ? "/" : data.path.split("/").pop() || data.path;
+      const tree = await buildTree(data.path, baseName, 0);
+      if (!tree) {
+        return { success: false, error: "Failed to access the specified path" };
+      }
+      return { success: true, tree };
+    } catch (error) {
+      types.logger.debug("Failed to get directory tree:", error);
+      return { success: false, error: error instanceof Error ? error.message : "Failed to get directory tree" };
+    }
+  });
+}
+
 async function start(credentials, options = {}) {
   const workingDirectory = process.cwd();
   const sessionTag = node_crypto.randomUUID();
-  const api = new ApiClient(credentials.token, credentials.secret);
+  const api = new types.ApiClient(credentials.token, credentials.secret);
   let state = {};
-  let metadata = { path: workingDirectory, host: os.hostname() };
+  let metadata = { path: workingDirectory, host: os.hostname(), version: packageJson.version, os: os.platform() };
   const response = await api.getOrCreateSession({ tag: sessionTag, metadata, state });
-  logger.debug(`Session created: ${response.id}`);
+  types.logger.debug(`Session created: ${response.id}`);
   const session = api.session(response);
   const pushClient = api.push();
+  let thinking = false;
+  let pingInterval = setInterval(() => {
+    session.keepAlive(thinking);
+  }, 2e3);
+  const antropicActivityProxy = await startAnthropicActivityProxy(
+    (activity) => {
+      const newThinking = activity === "working";
+      if (newThinking !== thinking) {
+        thinking = newThinking;
+        types.logger.debug(`[PING] Thinking state changed: ${thinking}`);
+        session.keepAlive(thinking);
+      }
+    }
+  );
+  process.env.HTTP_PROXY = antropicActivityProxy.url;
+  process.env.HTTPS_PROXY = antropicActivityProxy.url;
+  types.logger.debug(`[AnthropicProxy] Set HTTP_PROXY and HTTPS_PROXY to ${antropicActivityProxy.url}`);
+  const logPath = await types.logger.logFilePathPromise;
+  types.logger.infoDeveloper(`Session: ${response.id}`);
+  types.logger.infoDeveloper(`Logs: ${logPath}`);
   const interruptController = new InterruptController();
   let requests = /* @__PURE__ */ new Map();
   const permissionServer = await startPermissionServerV2(async (request) => {
@@ -1678,10 +1301,10 @@ async function start(credentials, options = {}) {
       requests.set(id, resolve);
     });
     let timeout = setTimeout(async () => {
-      logger.info("Permission timeout - attempting to interrupt Claude");
+      types.logger.info("Permission timeout - attempting to interrupt Claude");
       const interrupted = await interruptController.interrupt();
       if (interrupted) {
-        logger.info("Claude interrupted successfully");
+        types.logger.info("Claude interrupted successfully");
       }
       requests.delete(id);
       session.updateAgentState((currentState) => {
@@ -1693,7 +1316,7 @@ async function start(credentials, options = {}) {
         };
       });
     }, 1e3 * 60 * 4.5);
-    logger.info("Permission request" + id + " " + JSON.stringify(request));
+    types.logger.info("Permission request" + id + " " + JSON.stringify(request));
     try {
       await pushClient.sendToAllDevices(
         "Permission Request",
@@ -1705,9 +1328,9 @@ async function start(credentials, options = {}) {
           type: "permission_request"
         }
       );
-      logger.info("Push notification sent for permission request");
+      types.logger.info("Push notification sent for permission request");
     } catch (error) {
-      logger.debug("Failed to send push notification:", error);
+      types.logger.debug("Failed to send push notification:", error);
     }
     session.updateAgentState((currentState) => ({
       ...currentState,
@@ -1722,33 +1345,7 @@ async function start(credentials, options = {}) {
     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);
+  registerHandlers(session, interruptController, { requests });
   const onAssistantResult = async (result) => {
     try {
       const summary = "result" in result && result.result ? result.result.substring(0, 100) + (result.result.length > 100 ? "..." : "") : "";
@@ -1763,15 +1360,16 @@ async function start(credentials, options = {}) {
           cost_usd: result.total_cost_usd
         }
       );
-      logger.debug("Push notification sent: Assistant result");
+      types.logger.debug("Push notification sent: Assistant result");
     } catch (error) {
-      logger.debug("Failed to send assistant result push notification:", error);
+      types.logger.debug("Failed to send assistant result push notification:", error);
     }
   };
   await loop({
     path: workingDirectory,
     model: options.model,
     permissionMode: options.permissionMode,
+    startingMode: options.startingMode,
     mcpServers: {
       "permission": {
         type: "http",
@@ -1779,28 +1377,48 @@ async function start(credentials, options = {}) {
       }
     },
     permissionPromptToolName: "mcp__permission__" + permissionServer.toolName,
-    onThinking: (t) => {
-      thinking = t;
-      session.keepAlive(t);
-    },
     session,
     onAssistantResult,
     interruptController
   });
   clearInterval(pingInterval);
+  if (antropicActivityProxy) {
+    types.logger.debug("[AnthropicProxy] Shutting down thinking activity monitoring proxy");
+    antropicActivityProxy.cleanup();
+  }
   process.exit(0);
 }
 
+const defaultSettings = {
+  onboardingCompleted: false
+};
+async function readSettings() {
+  if (!node_fs.existsSync(types.configuration.settingsFile)) {
+    return { ...defaultSettings };
+  }
+  try {
+    const content = await promises.readFile(types.configuration.settingsFile, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return { ...defaultSettings };
+  }
+}
+async function writeSettings(settings) {
+  if (!node_fs.existsSync(types.configuration.happyDir)) {
+    await promises.mkdir(types.configuration.happyDir, { recursive: true });
+  }
+  await promises.writeFile(types.configuration.settingsFile, JSON.stringify(settings, null, 2));
+}
 const credentialsSchema = z__namespace.object({
   secret: z__namespace.string().base64(),
   token: z__namespace.string()
 });
 async function readCredentials() {
-  if (!node_fs.existsSync(configuration.privateKeyFile)) {
+  if (!node_fs.existsSync(types.configuration.privateKeyFile)) {
     return null;
   }
   try {
-    const keyBase64 = await promises.readFile(configuration.privateKeyFile, "utf8");
+    const keyBase64 = await promises.readFile(types.configuration.privateKeyFile, "utf8");
     const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
     return {
       secret: new Uint8Array(Buffer.from(credentials.secret, "base64")),
@@ -1811,11 +1429,11 @@ async function readCredentials() {
   }
 }
 async function writeCredentials(credentials) {
-  if (!node_fs.existsSync(configuration.happyDir)) {
-    await promises.mkdir(configuration.happyDir, { recursive: true });
+  if (!node_fs.existsSync(types.configuration.happyDir)) {
+    await promises.mkdir(types.configuration.happyDir, { recursive: true });
   }
-  await promises.writeFile(configuration.privateKeyFile, JSON.stringify({
-    secret: encodeBase64(credentials.secret),
+  await promises.writeFile(types.configuration.privateKeyFile, JSON.stringify({
+    secret: types.encodeBase64(credentials.secret),
     token: credentials.token
   }, null, 2));
 }
@@ -1837,24 +1455,29 @@ async function doAuth() {
   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)
+    await axios.post(`${types.configuration.serverUrl}/v1/auth/request`, {
+      publicKey: types.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));
+  const authUrl = "happy://terminal?" + types.encodeBase64Url(keypair.publicKey);
+  displayQRCode(authUrl);
+  if (process.env.DEBUG === "1") {
+    console.log("\n\u{1F4CB} For manual entry, copy this URL:");
+    console.log(authUrl);
+  }
   let credentials = null;
   while (true) {
     try {
-      const response = await axios.post(`${configuration.serverUrl}/v1/auth/request`, {
-        publicKey: encodeBase64(keypair.publicKey)
+      const response = await axios.post(`${types.configuration.serverUrl}/v1/auth/request`, {
+        publicKey: types.encodeBase64(keypair.publicKey)
       });
       if (response.data.state === "authorized") {
         let token = response.data.token;
-        let r = decodeBase64(response.data.response);
+        let r = types.decodeBase64(response.data.response);
         let decrypted = decryptWithEphemeralKey(r, keypair.secretKey);
         if (decrypted) {
           credentials = {
@@ -1872,7 +1495,7 @@ async function doAuth() {
       console.log("Failed to create authentication request, please try again later.");
       return null;
     }
-    await delay(1e3);
+    await types.delay(1e3);
   }
   return null;
 }
@@ -1887,12 +1510,361 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
   return decrypted;
 }
 
+class ApiDaemonSession extends node_events.EventEmitter {
+  socket;
+  machineIdentity;
+  keepAliveInterval = null;
+  token;
+  secret;
+  constructor(token, secret, machineIdentity) {
+    super();
+    this.token = token;
+    this.secret = secret;
+    this.machineIdentity = machineIdentity;
+    const socket = socket_ioClient.io(types.configuration.serverUrl, {
+      auth: {
+        token: this.token,
+        clientType: "machine-scoped",
+        machineId: this.machineIdentity.machineId
+      },
+      path: "/v1/user-machine-daemon",
+      reconnection: true,
+      reconnectionAttempts: Infinity,
+      reconnectionDelay: 1e3,
+      reconnectionDelayMax: 5e3,
+      transports: ["websocket"],
+      withCredentials: true,
+      autoConnect: false
+    });
+    socket.on("connect", () => {
+      types.logger.debug("[DAEMON] Connected to server");
+      this.emit("connected");
+      socket.emit("machine-connect", {
+        token: this.token,
+        machineIdentity: types.encodeBase64(types.encrypt(this.machineIdentity, this.secret))
+      });
+      this.startKeepAlive();
+    });
+    socket.on("disconnect", () => {
+      types.logger.debug("[DAEMON] Disconnected from server");
+      this.emit("disconnected");
+      this.stopKeepAlive();
+    });
+    socket.on("spawn-session", async (encryptedData, callback) => {
+      let requestData;
+      try {
+        requestData = types.decrypt(types.decodeBase64(encryptedData), this.secret);
+        types.logger.debug("[DAEMON] Received spawn-session request", requestData);
+        const args = [
+          "--directory",
+          requestData.directory,
+          "--happy-starting-mode",
+          requestData.startingMode
+        ];
+        if (requestData.metadata) {
+          args.push("--metadata", requestData.metadata);
+        }
+        if (requestData.startingMode === "interactive" && process.platform === "darwin") {
+          const script = `
+            tell application "Terminal"
+              activate
+              do script "cd ${requestData.directory} && happy ${args.join(" ")}"
+            end tell
+          `;
+          child_process.spawn("osascript", ["-e", script], { detached: true });
+        } else {
+          const child = child_process.spawn("happy", args, {
+            detached: true,
+            stdio: "ignore",
+            cwd: requestData.directory
+          });
+          child.unref();
+        }
+        const result = { success: true };
+        socket.emit("session-spawn-result", {
+          requestId: requestData.requestId,
+          result: types.encodeBase64(types.encrypt(result, this.secret))
+        });
+        callback(types.encodeBase64(types.encrypt({ success: true }, this.secret)));
+      } catch (error) {
+        types.logger.debug("[DAEMON] Failed to spawn session", error);
+        const errorResult = {
+          success: false,
+          error: error instanceof Error ? error.message : "Unknown error"
+        };
+        socket.emit("session-spawn-result", {
+          requestId: requestData?.requestId || "",
+          result: types.encodeBase64(types.encrypt(errorResult, this.secret))
+        });
+        callback(types.encodeBase64(types.encrypt(errorResult, this.secret)));
+      }
+    });
+    socket.on("daemon-command", (data) => {
+      switch (data.command) {
+        case "shutdown":
+          this.shutdown();
+          break;
+        case "status":
+          this.emit("status-request");
+          break;
+      }
+    });
+    this.socket = socket;
+  }
+  startKeepAlive() {
+    this.stopKeepAlive();
+    this.keepAliveInterval = setInterval(() => {
+      this.socket.volatile.emit("machine-alive", {
+        time: Date.now()
+      });
+    }, 2e4);
+  }
+  stopKeepAlive() {
+    if (this.keepAliveInterval) {
+      clearInterval(this.keepAliveInterval);
+      this.keepAliveInterval = null;
+    }
+  }
+  connect() {
+    this.socket.connect();
+  }
+  shutdown() {
+    this.stopKeepAlive();
+    this.socket.close();
+    this.emit("shutdown");
+  }
+}
+
+const DAEMON_PID_FILE = path.join(os$1.homedir(), ".happy", "daemon-pid");
+async function startDaemon() {
+  if (isDaemonRunning()) {
+    console.log("Happy daemon is already running");
+    process.exit(0);
+  }
+  types.logger.info("Happy CLI daemon started successfully");
+  writePidFile();
+  process.on("SIGINT", stopDaemon);
+  process.on("SIGTERM", stopDaemon);
+  process.on("exit", stopDaemon);
+  try {
+    const settings = await readSettings() || { onboardingCompleted: false };
+    if (!settings.machineId) {
+      settings.machineId = crypto.randomUUID();
+      settings.machineHost = os$1.hostname();
+      await writeSettings(settings);
+    }
+    const machineIdentity = {
+      machineId: settings.machineId,
+      machineHost: settings.machineHost || os$1.hostname(),
+      platform: process.platform,
+      version: process.env.npm_package_version || "unknown"
+    };
+    let credentials = await readCredentials();
+    if (!credentials) {
+      types.logger.debug("[DAEMON] No credentials found, running auth");
+      await doAuth();
+      credentials = await readCredentials();
+      if (!credentials) {
+        throw new Error("Failed to authenticate");
+      }
+    }
+    const { token, secret } = credentials;
+    const daemon = new ApiDaemonSession(token, secret, machineIdentity);
+    daemon.on("connected", () => {
+      types.logger.debug("[DAEMON] Successfully connected to server");
+    });
+    daemon.on("disconnected", () => {
+      types.logger.debug("[DAEMON] Disconnected from server");
+    });
+    daemon.on("shutdown", () => {
+      types.logger.debug("[DAEMON] Shutdown requested");
+      stopDaemon();
+      process.exit(0);
+    });
+    daemon.connect();
+    setInterval(() => {
+    }, 1e3);
+  } catch (error) {
+    types.logger.debug("[DAEMON] Failed to start daemon", error);
+    stopDaemon();
+    process.exit(1);
+  }
+  process.on("SIGINT", () => process.exit(0));
+  process.on("SIGTERM", () => process.exit(0));
+  process.on("exit", () => process.exit(0));
+  while (true) {
+    await new Promise((resolve) => setTimeout(resolve, 1e3));
+  }
+}
+function isDaemonRunning() {
+  try {
+    if (!fs.existsSync(DAEMON_PID_FILE)) {
+      console.log("No PID file found");
+      return false;
+    }
+    const pid = parseInt(fs.readFileSync(DAEMON_PID_FILE, "utf-8"));
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      console.log("Process not running", error);
+      fs.unlinkSync(DAEMON_PID_FILE);
+      return false;
+    }
+  } catch {
+    return false;
+  }
+}
+function writePidFile() {
+  const happyDir = path.join(os$1.homedir(), ".happy");
+  if (!fs.existsSync(happyDir)) {
+    fs.mkdirSync(happyDir, { recursive: true });
+  }
+  fs.writeFileSync(DAEMON_PID_FILE, process.pid.toString());
+}
+function stopDaemon() {
+  try {
+    if (fs.existsSync(DAEMON_PID_FILE)) {
+      types.logger.debug("[DAEMON] Stopping daemon");
+      process.kill(parseInt(fs.readFileSync(DAEMON_PID_FILE, "utf-8")), "SIGTERM");
+      fs.unlinkSync(DAEMON_PID_FILE);
+    }
+  } catch (error) {
+    types.logger.debug("[DAEMON] Error cleaning up PID file", error);
+  }
+}
+
+function trimIdent(text) {
+  const lines = text.split("\n");
+  while (lines.length > 0 && lines[0].trim() === "") {
+    lines.shift();
+  }
+  while (lines.length > 0 && lines[lines.length - 1].trim() === "") {
+    lines.pop();
+  }
+  const minSpaces = lines.reduce((min, line) => {
+    if (line.trim() === "") {
+      return min;
+    }
+    const leadingSpaces = line.match(/^\s*/)[0].length;
+    return Math.min(min, leadingSpaces);
+  }, Infinity);
+  const trimmedLines = lines.map((line) => line.slice(minSpaces));
+  return trimmedLines.join("\n");
+}
+
+const PLIST_LABEL$1 = "com.happy-cli.daemon";
+const PLIST_FILE$1 = `/Library/LaunchDaemons/${PLIST_LABEL$1}.plist`;
+const USER_HOME = process.env.HOME || process.env.USERPROFILE;
+async function install$1() {
+  try {
+    if (fs.existsSync(PLIST_FILE$1)) {
+      types.logger.info("Daemon plist already exists. Uninstalling first...");
+      child_process.execSync(`launchctl unload ${PLIST_FILE$1}`, { stdio: "inherit" });
+    }
+    const happyPath = process.argv[0];
+    const scriptPath = process.argv[1];
+    const plistContent = trimIdent(`
+            <?xml version="1.0" encoding="UTF-8"?>
+            <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+            <plist version="1.0">
+            <dict>
+                <key>Label</key>
+                <string>${PLIST_LABEL$1}</string>
+                
+                <key>ProgramArguments</key>
+                <array>
+                    <string>${happyPath}</string>
+                    <string>${scriptPath}</string>
+                    <string>happy-daemon</string>
+                </array>
+                
+                <key>EnvironmentVariables</key>
+                <dict>
+                    <key>HAPPY_DAEMON_MODE</key>
+                    <string>true</string>
+                </dict>
+                
+                <key>RunAtLoad</key>
+                <true/>
+                
+                <key>KeepAlive</key>
+                <true/>
+                
+                <key>StandardErrorPath</key>
+                <string>${USER_HOME}/.happy/daemon.err</string>
+                
+                <key>StandardOutPath</key>
+                <string>${USER_HOME}/.happy/daemon.log</string>
+                
+                <key>WorkingDirectory</key>
+                <string>/tmp</string>
+            </dict>
+            </plist>
+        `);
+    fs.writeFileSync(PLIST_FILE$1, plistContent);
+    fs.chmodSync(PLIST_FILE$1, 420);
+    types.logger.info(`Created daemon plist at ${PLIST_FILE$1}`);
+    child_process.execSync(`launchctl load ${PLIST_FILE$1}`, { stdio: "inherit" });
+    types.logger.info("Daemon installed and started successfully");
+    types.logger.info("Check logs at ~/.happy/daemon.log");
+  } catch (error) {
+    types.logger.debug("Failed to install daemon:", error);
+    throw error;
+  }
+}
+
+async function install() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon installation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon installation requires sudo privileges. Please run with sudo.");
+  }
+  types.logger.info("Installing Happy CLI daemon for macOS...");
+  await install$1();
+}
+
+const PLIST_LABEL = "com.happy-cli.daemon";
+const PLIST_FILE = `/Library/LaunchDaemons/${PLIST_LABEL}.plist`;
+async function uninstall$1() {
+  try {
+    if (!fs.existsSync(PLIST_FILE)) {
+      types.logger.info("Daemon plist not found. Nothing to uninstall.");
+      return;
+    }
+    try {
+      child_process.execSync(`launchctl unload ${PLIST_FILE}`, { stdio: "inherit" });
+      types.logger.info("Daemon stopped successfully");
+    } catch (error) {
+      types.logger.info("Failed to unload daemon (it might not be running)");
+    }
+    fs.unlinkSync(PLIST_FILE);
+    types.logger.info(`Removed daemon plist from ${PLIST_FILE}`);
+    types.logger.info("Daemon uninstalled successfully");
+  } catch (error) {
+    types.logger.debug("Failed to uninstall daemon:", error);
+    throw error;
+  }
+}
+
+async function uninstall() {
+  if (process.platform !== "darwin") {
+    throw new Error("Daemon uninstallation is currently only supported on macOS");
+  }
+  if (process.getuid && process.getuid() !== 0) {
+    throw new Error("Daemon uninstallation requires sudo privileges. Please run with sudo.");
+  }
+  types.logger.info("Uninstalling Happy CLI daemon for macOS...");
+  await uninstall$1();
+}
+
 (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);
+  types.initializeConfiguration(installationLocation);
+  types.initLoggerWithGlobalConfiguration();
+  types.logger.debug("Starting happy CLI with args: ", process.argv);
   const subcommand = args[0];
   if (subcommand === "logout") {
     try {
@@ -1905,25 +1877,64 @@ function decryptWithEphemeralKey(encryptedBundle, recipientSecretKey) {
       process.exit(1);
     }
     return;
-  } else if (subcommand === "login" || subcommand === "auth") {
-    await doAuth();
+  } else if (subcommand === "daemon") {
+    const daemonSubcommand = args[1];
+    if (daemonSubcommand === "start") {
+      await startDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "stop") {
+      await stopDaemon();
+      process.exit(0);
+    } else if (daemonSubcommand === "install") {
+      try {
+        await install();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else if (daemonSubcommand === "uninstall") {
+      try {
+        await uninstall();
+      } catch (error) {
+        console.error(chalk.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    } else {
+      console.log(`
+${chalk.bold("happy daemon")} - Daemon management
+
+${chalk.bold("Usage:")}
+  happy daemon start            Start the daemon
+  happy daemon stop             Stop the daemon
+  sudo happy daemon install     Install the daemon (requires sudo)
+  sudo happy daemon uninstall   Uninstall the daemon (requires sudo)
+
+${chalk.bold("Note:")} The daemon runs in the background and provides persistent services.
+Currently only supported on macOS.
+`);
+    }
     return;
   } else {
     const options = {};
     let showHelp = false;
     let showVersion = false;
+    let forceAuth = false;
     for (let i = 0; i < args.length; i++) {
       const arg = args[i];
       if (arg === "-h" || arg === "--help") {
         showHelp = true;
       } else if (arg === "-v" || arg === "--version") {
         showVersion = true;
+      } else if (arg === "--auth" || arg === "--login") {
+        forceAuth = true;
       } else if (arg === "-m" || arg === "--model") {
         options.model = args[++i];
       } else if (arg === "-p" || arg === "--permission-mode") {
-        options.permissionMode = args[++i];
+        options.permissionMode = z.z.enum(["auto", "default", "plan"]).parse(args[++i]);
       } else if (arg === "--local") {
         i++;
+      } else if (arg === "--happy-starting-mode") {
+        options.startingMode = z.z.enum(["interactive", "remote"]).parse(args[++i]);
       } else {
         console.error(chalk.red(`Unknown argument: ${arg}`));
         process.exit(1);
@@ -1936,35 +1947,36 @@ ${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
   -v, --version           Show version
   -m, --model <model>     Claude model to use (default: sonnet)
   -p, --permission-mode   Permission mode: auto, default, or plan
+  --auth, --login         Force re-authentication
 
   [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.
+  --happy-starting-mode <interactive|remote>
+      Set the starting mode for new sessions (default: remote)
 
 ${chalk.bold("Examples:")}
   happy                   Start a session with default settings
   happy -m opus           Use Claude Opus model
   happy -p plan           Use plan permission mode
+  happy --auth            Force re-authentication before starting session
   happy logout            Logs out of your account and removes data directory
 `);
       process.exit(0);
     }
     if (showVersion) {
-      console.log("0.1.3");
+      console.log(packageJson.version);
       process.exit(0);
     }
     let credentials = await readCredentials();
-    if (!credentials) {
+    if (!credentials || forceAuth) {
       let res = await doAuth();
       if (!res) {
         process.exit(1);
@@ -1983,7 +1995,7 @@ ${chalk.bold("Examples:")}
   }
 })();
 async function cleanKey() {
-  const happyDir = configuration.happyDir;
+  const happyDir = types.configuration.happyDir;
   if (!node_fs.existsSync(happyDir)) {
     console.log(chalk.yellow("No happy data directory found at:"), happyDir);
     return;