@tongil_kim/clautunnel 0.1.9

package/dist/index.js

@@ -0,0 +1,3168 @@
+#!/usr/bin/env node
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../packages/shared/dist/types/message.js
+var require_message = __commonJS({
+  "../../packages/shared/dist/types/message.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../packages/shared/dist/types/session.js
+var require_session = __commonJS({
+  "../../packages/shared/dist/types/session.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../packages/shared/dist/types/machine.js
+var require_machine = __commonJS({
+  "../../packages/shared/dist/types/machine.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../packages/shared/dist/types/presence.js
+var require_presence = __commonJS({
+  "../../packages/shared/dist/types/presence.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+  }
+});
+
+// ../../packages/shared/dist/types/index.js
+var require_types = __commonJS({
+  "../../packages/shared/dist/types/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_message(), exports);
+    __exportStar(require_session(), exports);
+    __exportStar(require_machine(), exports);
+    __exportStar(require_presence(), exports);
+  }
+});
+
+// ../../packages/shared/dist/constants/events.js
+var require_events = __commonJS({
+  "../../packages/shared/dist/constants/events.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.REALTIME_CHANNELS = void 0;
+    exports.REALTIME_CHANNELS = {
+      sessionOutput: (sessionId) => `session:${sessionId}:output`,
+      sessionInput: (sessionId) => `session:${sessionId}:input`,
+      sessionPresence: (sessionId) => `session:${sessionId}:presence`,
+      machinePresence: (machineId) => `machine:${machineId}:presence`,
+      machineInput: (machineId) => `machine:${machineId}:input`,
+      machineOutput: (machineId) => `machine:${machineId}:output`
+    };
+  }
+});
+
+// ../../packages/shared/dist/constants/index.js
+var require_constants = __commonJS({
+  "../../packages/shared/dist/constants/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_events(), exports);
+  }
+});
+
+// ../../packages/shared/dist/index.js
+var require_dist = __commonJS({
+  "../../packages/shared/dist/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    __exportStar(require_types(), exports);
+    __exportStar(require_constants(), exports);
+  }
+});
+
+// src/index.ts
+import { config } from "dotenv";
+import { resolve, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { fileURLToPath } from "url";
+
+// src/utils/config.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var ConfigurationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+};
+var Config = class {
+  configDir;
+  configFile;
+  data;
+  constructor(configDir) {
+    this.configDir = configDir ?? join(homedir(), ".clautunnel");
+    this.configFile = join(this.configDir, "config.json");
+    this.data = this.loadConfig();
+  }
+  loadConfig() {
+    if (existsSync(this.configFile)) {
+      try {
+        return JSON.parse(readFileSync(this.configFile, "utf-8"));
+      } catch {
+        return {};
+      }
+    }
+    return {};
+  }
+  saveConfig() {
+    if (!existsSync(this.configDir)) {
+      mkdirSync(this.configDir, { recursive: true });
+    }
+    writeFileSync(this.configFile, JSON.stringify(this.data, null, 2));
+  }
+  getSupabaseUrl() {
+    const url = process.env["SUPABASE_URL"] || this.data.supabaseUrl;
+    if (!url) {
+      throw new Error("SUPABASE_URL environment variable is not set");
+    }
+    try {
+      new URL(url);
+    } catch {
+      throw new Error("SUPABASE_URL must be a valid URL");
+    }
+    return url;
+  }
+  getSupabaseAnonKey() {
+    const key = process.env["SUPABASE_ANON_KEY"] || this.data.supabaseAnonKey;
+    if (!key) {
+      throw new Error("SUPABASE_ANON_KEY environment variable is not set");
+    }
+    return key;
+  }
+  setSupabaseCredentials(credentials) {
+    this.data.supabaseUrl = credentials.url;
+    this.data.supabaseAnonKey = credentials.anonKey;
+    this.saveConfig();
+  }
+  isConfigured() {
+    const hasEnvVars = !!(process.env["SUPABASE_URL"] && process.env["SUPABASE_ANON_KEY"]);
+    const hasConfigFile = !!(this.data.supabaseUrl && this.data.supabaseAnonKey);
+    return hasEnvVars || hasConfigFile;
+  }
+  requireConfiguration() {
+    if (!this.isConfigured()) {
+      throw new ConfigurationError(
+        'ClauTunnel is not configured.\n\nPlease run "clautunnel setup" to configure your Supabase credentials,\nor set the following environment variables:\n  - SUPABASE_URL\n  - SUPABASE_ANON_KEY'
+      );
+    }
+  }
+  getMachineId() {
+    return this.data.machineId;
+  }
+  setMachineId(machineId) {
+    this.data.machineId = machineId;
+    this.saveConfig();
+  }
+  getSessionTokens() {
+    return this.data.sessionTokens;
+  }
+  setSessionTokens(tokens) {
+    this.data.sessionTokens = tokens;
+    this.saveConfig();
+  }
+  // Alias for setSessionTokens
+  setSession(tokens) {
+    this.setSessionTokens(tokens);
+  }
+  clearSessionTokens() {
+    delete this.data.sessionTokens;
+    this.saveConfig();
+  }
+};
+var defaultConfig = null;
+function getConfig() {
+  if (!defaultConfig) {
+    defaultConfig = new Config();
+  }
+  return defaultConfig;
+}
+
+// src/utils/logger.ts
+var Logger = class {
+  silent;
+  debugEnabled;
+  constructor() {
+    this.silent = process.env["SILENT"] === "true";
+    this.debugEnabled = process.env["DEBUG"] === "true";
+  }
+  formatTimestamp() {
+    const now = /* @__PURE__ */ new Date();
+    return now.toTimeString().split(" ")[0] ?? now.toISOString();
+  }
+  formatMessage(level, message, data) {
+    const timestamp = this.formatTimestamp();
+    const levelStr = level.toUpperCase().padEnd(5);
+    let formatted = `[${timestamp}] [${levelStr}] ${message}`;
+    if (data) {
+      formatted += ` ${JSON.stringify(data)}`;
+    }
+    return formatted;
+  }
+  debug(message, data) {
+    if (this.silent || !this.debugEnabled) return;
+    console.log(this.formatMessage("debug", message, data));
+  }
+  info(message, data) {
+    if (this.silent) return;
+    console.log(this.formatMessage("info", message, data));
+  }
+  warn(message, data) {
+    if (this.silent) return;
+    console.warn(this.formatMessage("warn", message, data));
+  }
+  error(message, data) {
+    if (this.silent) return;
+    console.error(this.formatMessage("error", message, data));
+  }
+};
+var defaultLogger = null;
+function getLogger() {
+  if (!defaultLogger) {
+    defaultLogger = new Logger();
+  }
+  return defaultLogger;
+}
+
+// src/realtime/client.ts
+var import_clautunnel_shared = __toESM(require_dist(), 1);
+import { EventEmitter } from "events";
+
+// src/realtime/utils.ts
+var DEFAULT_TIMEOUT = 1e4;
+function subscribeWithTimeout(channel, channelName, timeout = DEFAULT_TIMEOUT) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(() => {
+      console.warn(
+        `[WARN] Realtime subscription timeout for ${channelName}. Mobile sync disabled.`
+      );
+      resolve2(false);
+    }, timeout);
+    channel.subscribe((status, err) => {
+      if (status === "SUBSCRIBED") {
+        clearTimeout(timer);
+        resolve2(true);
+      } else if (status === "CHANNEL_ERROR" || status === "CLOSED" || status === "TIMED_OUT") {
+        clearTimeout(timer);
+        console.warn(
+          `[WARN] Channel ${channelName} ${status.toLowerCase()}. Mobile sync disabled.`
+        );
+        if (err) {
+          console.warn(`[WARN] Error details: ${err.message || err}`);
+        }
+        resolve2(false);
+      }
+    });
+  });
+}
+
+// src/realtime/client.ts
+var RealtimeClient = class extends EventEmitter {
+  supabase;
+  sessionId;
+  outputChannel = null;
+  inputChannel = null;
+  presenceChannel = null;
+  seq = 0;
+  realtimeEnabled = false;
+  constructor(options) {
+    super();
+    this.supabase = options.supabase;
+    this.sessionId = options.sessionId;
+  }
+  async connect() {
+    const outputChannelName = import_clautunnel_shared.REALTIME_CHANNELS.sessionOutput(this.sessionId);
+    this.outputChannel = this.supabase.channel(outputChannelName);
+    const inputChannelName = import_clautunnel_shared.REALTIME_CHANNELS.sessionInput(this.sessionId);
+    this.inputChannel = this.supabase.channel(inputChannelName);
+    this.inputChannel.on("broadcast", { event: "input" }, (payload) => {
+      this.emit("input", payload.payload);
+    });
+    const results = await Promise.all([
+      subscribeWithTimeout(this.outputChannel, "output"),
+      subscribeWithTimeout(this.inputChannel, "input")
+    ]);
+    this.realtimeEnabled = results.every((success) => success);
+    if (this.realtimeEnabled) {
+      const presenceChannelName = import_clautunnel_shared.REALTIME_CHANNELS.sessionPresence(this.sessionId);
+      this.presenceChannel = this.supabase.channel(presenceChannelName);
+      this.presenceChannel.subscribe(async (status, err) => {
+        if (status === "SUBSCRIBED" && this.presenceChannel) {
+          try {
+            const payload = {
+              type: "cli",
+              online_at: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            await this.presenceChannel.track(payload);
+          } catch (trackError) {
+            console.warn("[WARN] Failed to track presence:", trackError);
+          }
+        } else if (status === "CHANNEL_ERROR") {
+          console.warn("[WARN] Presence channel error:", err?.message || "Unknown error");
+        }
+      });
+    }
+    this.emit("connected");
+  }
+  async disconnect() {
+    if (this.presenceChannel) {
+      await this.presenceChannel.untrack();
+      await this.supabase.removeChannel(this.presenceChannel);
+      this.presenceChannel = null;
+    }
+    if (this.outputChannel) {
+      await this.supabase.removeChannel(this.outputChannel);
+      this.outputChannel = null;
+    }
+    if (this.inputChannel) {
+      await this.supabase.removeChannel(this.inputChannel);
+      this.inputChannel = null;
+    }
+    this.emit("disconnected");
+  }
+  async broadcast(content) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    const message = {
+      type: "output",
+      content,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    try {
+      const { error } = await this.supabase.from("messages").insert({
+        session_id: this.sessionId,
+        type: message.type,
+        content: message.content,
+        seq: message.seq
+      });
+      if (error) {
+        console.warn("[WARN] Failed to persist message:", error.message);
+      }
+    } catch (error) {
+      console.warn("[WARN] Failed to persist message:", error);
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    try {
+      await this.outputChannel.send({
+        type: "broadcast",
+        event: "output",
+        payload: message
+      });
+    } catch (error) {
+      throw error;
+    }
+    this.emit("broadcast", message);
+  }
+  async broadcastMode(mode) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "mode",
+      permissionMode: mode,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastCommands(commands) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "commands",
+      commands,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastModel(model) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "model",
+      model,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastModels(models) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "models",
+      availableModels: models,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastSystem(content) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    const message = {
+      type: "system",
+      content,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    try {
+      const { error } = await this.supabase.from("messages").insert({
+        session_id: this.sessionId,
+        type: message.type,
+        content: message.content,
+        seq: message.seq
+      });
+      if (error) {
+        console.warn("[WARN] Failed to persist system message:", error.message);
+      }
+    } catch (error) {
+      console.warn("[WARN] Failed to persist system message:", error);
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    try {
+      await this.outputChannel.send({
+        type: "broadcast",
+        event: "output",
+        payload: message
+      });
+    } catch (error) {
+      throw error;
+    }
+    this.emit("broadcast", message);
+  }
+  async broadcastInteractiveResponse(data) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "interactive-response",
+      interactiveData: data,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastInteractiveConfirm(command, result) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "interactive-confirm",
+      interactiveCommand: command,
+      interactiveResult: result,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastResumeHistory(historySessionId) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "resume-history",
+      historySessionId,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastUserQuestion(questionData) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "user-question",
+      userQuestion: questionData,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastPermissionRequest(requestData) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "permission-request",
+      permissionRequest: requestData,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastToolUse(toolUseData) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    const message = {
+      type: "tool-use",
+      toolUseData,
+      content: JSON.stringify(toolUseData),
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    try {
+      const { error } = await this.supabase.from("messages").insert({
+        session_id: this.sessionId,
+        type: message.type,
+        content: message.content,
+        seq: message.seq
+      });
+      if (error) {
+        console.warn("[WARN] Failed to persist tool-use message:", error.message);
+      }
+    } catch (error) {
+      console.warn("[WARN] Failed to persist tool-use message:", error);
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    try {
+      await this.outputChannel.send({
+        type: "broadcast",
+        event: "output",
+        payload: message
+      });
+    } catch (error) {
+      throw error;
+    }
+    this.emit("broadcast", message);
+  }
+  async broadcastComplete() {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "complete",
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastSessionTitle(title) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "session-title",
+      sessionTitle: title,
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastQueued() {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "request-queued",
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  async broadcastError(errorMessage, errorCode) {
+    if (!this.outputChannel) {
+      throw new Error("Not connected");
+    }
+    if (!this.realtimeEnabled) {
+      return;
+    }
+    const message = {
+      type: "error",
+      content: errorMessage,
+      errorCode: errorCode || "unknown",
+      timestamp: Date.now(),
+      seq: ++this.seq
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "output",
+      payload: message
+    });
+    this.emit("broadcast", message);
+  }
+  getSeq() {
+    return this.seq;
+  }
+  isConnected() {
+    return this.outputChannel !== null && this.inputChannel !== null;
+  }
+  isRealtimeEnabled() {
+    return this.realtimeEnabled;
+  }
+};
+
+// src/daemon/session.ts
+var SessionManager = class {
+  supabase;
+  constructor(options) {
+    this.supabase = options.supabase;
+  }
+  async createSession(machineId, workingDirectory) {
+    const { data, error } = await this.supabase.from("sessions").insert({
+      machine_id: machineId,
+      status: "active",
+      working_directory: workingDirectory,
+      started_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).select().single();
+    if (error) {
+      throw new Error(`Failed to create session: ${error.message}`);
+    }
+    return data;
+  }
+  async endSession(sessionId) {
+    const { error } = await this.supabase.from("sessions").update({
+      status: "ended",
+      ended_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", sessionId);
+    if (error) {
+      throw new Error(`Failed to end session: ${error.message}`);
+    }
+  }
+  async getSession(sessionId) {
+    const { data, error } = await this.supabase.from("sessions").select().eq("id", sessionId).single();
+    if (error) {
+      if (error.code === "PGRST116") {
+        return null;
+      }
+      throw new Error(`Failed to get session: ${error.message}`);
+    }
+    return data;
+  }
+  async updateSessionStatus(sessionId, status) {
+    const updates = { status };
+    if (status === "ended") {
+      updates.ended_at = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    const { error } = await this.supabase.from("sessions").update(updates).eq("id", sessionId);
+    if (error) {
+      throw new Error(`Failed to update session status: ${error.message}`);
+    }
+  }
+  async updateSessionModel(sessionId, model) {
+    const { error } = await this.supabase.from("sessions").update({ model }).eq("id", sessionId);
+    if (error) {
+      throw new Error(`Failed to update session model: ${error.message}`);
+    }
+  }
+  async updateSdkSessionId(sessionId, sdkSessionId) {
+    const { error } = await this.supabase.from("sessions").update({ sdk_session_id: sdkSessionId }).eq("id", sessionId);
+    if (error) {
+      throw new Error(`Failed to update SDK session ID: ${error.message}`);
+    }
+  }
+  async updateSessionTitle(sessionId, title) {
+    const { error } = await this.supabase.from("sessions").update({ title }).eq("id", sessionId);
+    if (error) {
+      throw new Error(`Failed to update session title: ${error.message}`);
+    }
+  }
+};
+
+// src/daemon/machine.ts
+import * as os from "os";
+var MachineManager = class {
+  supabase;
+  constructor(options) {
+    this.supabase = options.supabase;
+  }
+  async registerMachine(userId, name, machineId) {
+    const hostname2 = os.hostname();
+    const machineName = name || hostname2;
+    if (machineId) {
+      const existing = await this.getMachine(machineId);
+      if (existing) {
+        await this.updateMachineStatus(machineId, "online");
+        return existing;
+      }
+    }
+    const { data: existingByHostname } = await this.supabase.from("machines").select().eq("user_id", userId).eq("hostname", hostname2).single();
+    if (existingByHostname) {
+      await this.updateMachineStatus(existingByHostname.id, "online");
+      return existingByHostname;
+    }
+    const { data, error } = await this.supabase.from("machines").insert({
+      user_id: userId,
+      name: machineName,
+      hostname: hostname2,
+      status: "online",
+      last_seen_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).select().single();
+    if (error) {
+      throw new Error(`Failed to register machine: ${error.message}`);
+    }
+    return data;
+  }
+  async getMachine(machineId) {
+    const { data, error } = await this.supabase.from("machines").select().eq("id", machineId).single();
+    if (error) {
+      if (error.code === "PGRST116") {
+        return null;
+      }
+      throw new Error(`Failed to get machine: ${error.message}`);
+    }
+    return data;
+  }
+  async updateMachineStatus(machineId, status) {
+    const { error } = await this.supabase.from("machines").update({
+      status,
+      last_seen_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", machineId);
+    if (error) {
+      throw new Error(`Failed to update machine status: ${error.message}`);
+    }
+  }
+  async heartbeat(machineId) {
+    const { error } = await this.supabase.from("machines").update({
+      last_seen_at: (/* @__PURE__ */ new Date()).toISOString()
+    }).eq("id", machineId);
+    if (error) {
+      throw new Error(`Failed to update heartbeat: ${error.message}`);
+    }
+  }
+  async listMachines(userId) {
+    const { data, error } = await this.supabase.from("machines").select().eq("user_id", userId).order("last_seen_at", { ascending: false });
+    if (error) {
+      throw new Error(`Failed to list machines: ${error.message}`);
+    }
+    return data;
+  }
+};
+
+// src/daemon/daemon.ts
+import { EventEmitter as EventEmitter3 } from "events";
+
+// src/daemon/sdk-session.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import * as fs from "fs";
+import * as path from "path";
+import * as os2 from "os";
+import { unstable_v2_createSession, unstable_v2_resumeSession } from "@anthropic-ai/claude-agent-sdk";
+import { v4 as uuidv4 } from "uuid";
+var MAX_TOOL_CONTENT = 1e4;
+var UNSUPPORTED_COMMANDS = /* @__PURE__ */ new Set([
+  "keybindings-help",
+  "help",
+  "context",
+  "cost",
+  "release-notes",
+  "vim",
+  "mcp",
+  "agents",
+  "hooks",
+  "status"
+]);
+var SdkSession = class extends EventEmitter2 {
+  options;
+  sessionId = null;
+  isProcessing = false;
+  currentPermissionMode;
+  v2Session = null;
+  streamLoopRunning = false;
+  cachedCommands = null;
+  cachedModels = null;
+  currentModel = "opus";
+  conversationHistory = [];
+  pendingContextTransfer = false;
+  thinkingEnabled = false;
+  pendingPermissionRequests = /* @__PURE__ */ new Map();
+  // Pending AskUserQuestion answer resolver - resolved by provideAnswer()
+  pendingAnswerResolve = null;
+  // Track pending question/permission data for re-broadcast on status-request
+  pendingQuestionData = null;
+  pendingPermissionData = null;
+  // Track current assistant response text for conversation history
+  currentAssistantResponse = "";
+  // Queued prompt to send after current processing completes (last-one-wins)
+  pendingPrompt = null;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.currentPermissionMode = options.permissionMode || "default";
+    this.currentModel = options.model || "opus";
+  }
+  /**
+   * Handle permission response from mobile
+   */
+  handlePermissionResponse(response) {
+    const pending = this.pendingPermissionRequests.get(response.requestId);
+    if (!pending) {
+      console.warn(`[WARN] No pending permission request found for ID: ${response.requestId}`);
+      return;
+    }
+    this.pendingPermissionRequests.delete(response.requestId);
+    this.pendingPermissionData = null;
+    if (response.behavior === "allow") {
+      const result = {
+        behavior: "allow",
+        updatedInput: response.updatedInput,
+        updatedPermissions: response.updatedPermissions
+      };
+      pending.resolve(result);
+    } else {
+      const result = {
+        behavior: "deny",
+        message: response.message || "Permission denied by user"
+      };
+      pending.resolve(result);
+    }
+  }
+  /**
+   * Create canUseTool callback for SDK
+   *
+   * AskUserQuestion goes through this path: the subprocess sends a
+   * control_request with subtype "can_use_tool" and blocks until a
+   * control_response is returned.  For AskUserQuestion we emit a
+   * user-question event, wait for provideAnswer() to resolve the pending
+   * promise, and return {behavior:'allow', updatedInput:{questions, answers}}
+   * so the subprocess can produce the tool_result and continue.
+   */
+  createCanUseTool() {
+    return async (toolName, input, options) => {
+      if (toolName === "AskUserQuestion") {
+        const questionInput = input;
+        if (questionInput.questions && Array.isArray(questionInput.questions)) {
+          const questions = questionInput.questions.map((q) => ({
+            question: q.question,
+            header: q.header,
+            options: (q.options || []).map((o) => ({
+              label: o.label,
+              description: o.description
+            })),
+            multiSelect: q.multiSelect
+          }));
+          const questionData = {
+            toolUseId: options.toolUseID,
+            questions
+          };
+          this.pendingQuestionData = questionData;
+          this.emit("user-question", questionData);
+          const answers = await new Promise(
+            (resolve2, reject) => {
+              this.pendingAnswerResolve = resolve2;
+              options.signal.addEventListener("abort", () => {
+                this.pendingAnswerResolve = null;
+                this.pendingQuestionData = null;
+                reject(new Error("Question aborted"));
+              });
+            }
+          );
+          this.pendingAnswerResolve = null;
+          this.pendingQuestionData = null;
+          return {
+            behavior: "allow",
+            updatedInput: {
+              questions: questionInput.questions,
+              answers
+            }
+          };
+        }
+      }
+      const requestId = uuidv4();
+      const suggestions = options.suggestions?.map((s) => {
+        if (s.type === "addRules" || s.type === "replaceRules" || s.type === "removeRules") {
+          return {
+            type: s.type,
+            rules: s.rules,
+            behavior: s.behavior,
+            destination: s.destination
+          };
+        } else if (s.type === "setMode") {
+          return {
+            type: "setMode",
+            mode: s.mode,
+            destination: s.destination
+          };
+        } else if (s.type === "addDirectories" || s.type === "removeDirectories") {
+          return {
+            type: s.type,
+            directories: s.directories,
+            destination: s.destination
+          };
+        }
+        return s;
+      });
+      const requestData = {
+        requestId,
+        toolName,
+        toolInput: input,
+        toolUseId: options.toolUseID,
+        suggestions,
+        blockedPath: options.blockedPath,
+        decisionReason: options.decisionReason,
+        agentId: options.agentID
+      };
+      this.pendingPermissionData = requestData;
+      this.emit("permission-request", requestData);
+      return new Promise((resolve2, reject) => {
+        this.pendingPermissionRequests.set(requestId, {
+          resolve: resolve2,
+          reject,
+          signal: options.signal
+        });
+        options.signal.addEventListener("abort", () => {
+          this.pendingPermissionRequests.delete(requestId);
+          this.pendingPermissionData = null;
+          reject(new Error("Permission request aborted"));
+        });
+      });
+    };
+  }
+  setPermissionMode(mode) {
+    this.currentPermissionMode = mode;
+    this.emit("permission-mode", mode);
+  }
+  getPermissionMode() {
+    return this.currentPermissionMode;
+  }
+  async setThinkingMode(enabled) {
+    this.thinkingEnabled = enabled;
+    this.emit("thinking-mode", enabled);
+  }
+  getThinkingMode() {
+    return this.thinkingEnabled;
+  }
+  /**
+   * Build V2 session options from current state
+   */
+  buildSessionOptions() {
+    const opts = {
+      // SDK accepts shorthand model names: 'opus' | 'sonnet' | 'haiku'
+      // Full model IDs (e.g. 'claude-opus-4-6') are also valid but shorthand is preferred
+      model: this.currentModel,
+      allowedTools: this.options.allowedTools || ["Read", "Edit", "Write", "Bash", "Glob", "Grep"],
+      canUseTool: this.createCanUseTool(),
+      permissionMode: this.currentPermissionMode
+    };
+    return opts;
+  }
+  /**
+   * Ensure a V2 session exists, creating one if needed
+   */
+  ensureSession() {
+    if (!this.v2Session) {
+      const opts = this.buildSessionOptions();
+      if (this.sessionId) {
+        this.v2Session = unstable_v2_resumeSession(this.sessionId, opts);
+      } else {
+        this.v2Session = unstable_v2_createSession(opts);
+      }
+      this.startStreamLoop();
+    }
+    return this.v2Session;
+  }
+  /**
+   * Background loop that processes messages from the V2 session stream.
+   * Runs continuously for the lifetime of the session.
+   */
+  async startStreamLoop() {
+    if (this.streamLoopRunning || !this.v2Session) return;
+    this.streamLoopRunning = true;
+    try {
+      while (this.v2Session && !this.v2Session["closed"]) {
+        for await (const message of this.v2Session.stream()) {
+          this.processMessage(message);
+        }
+      }
+    } catch (error) {
+      if (error.name !== "AbortError") {
+        this.emit("error", error);
+      }
+    } finally {
+      this.streamLoopRunning = false;
+      if (this.isProcessing) {
+        this.isProcessing = false;
+        this.pendingPrompt = null;
+        this.emit("complete");
+      }
+    }
+  }
+  /**
+   * Process a single SDK message from the stream
+   */
+  processMessage(message) {
+    if (message.type === "system" && "subtype" in message && message.subtype === "init") {
+      this.sessionId = message.session_id;
+      this.emit("session-started", this.sessionId);
+      if ("permissionMode" in message) {
+        this.emit("permission-mode", message.permissionMode);
+      }
+      if ("slash_commands" in message && Array.isArray(message.slash_commands)) {
+        this.cachedCommands = message.slash_commands.map((cmd) => {
+          if (typeof cmd === "string") {
+            return { name: cmd, description: "", argumentHint: "" };
+          } else if (typeof cmd === "object" && cmd !== null) {
+            const cmdObj = cmd;
+            return {
+              name: cmdObj.name || "",
+              description: cmdObj.description || "",
+              argumentHint: cmdObj.argumentHint || ""
+            };
+          }
+          return { name: String(cmd), description: "", argumentHint: "" };
+        });
+        this.emit("commands-updated", this.cachedCommands);
+      }
+    } else if (message.type === "assistant") {
+      if (message.message?.content) {
+        for (const block of message.message.content) {
+          if ("type" in block && block.type === "text" && "text" in block) {
+            this.emit("output", block.text);
+            this.currentAssistantResponse += block.text;
+          } else if ("type" in block && block.type === "tool_use" && "name" in block) {
+            const toolName = block.name;
+            if (toolName !== "AskUserQuestion") {
+              const input = block.input || {};
+              let toolUseData;
+              if (toolName === "Edit" && input.file_path && input.old_string !== void 0) {
+                toolUseData = {
+                  action: "Edit",
+                  filePath: input.file_path,
+                  oldString: String(input.old_string).slice(0, MAX_TOOL_CONTENT),
+                  newString: String(input.new_string || "").slice(0, MAX_TOOL_CONTENT)
+                };
+              } else if (toolName === "Write" && input.file_path) {
+                toolUseData = {
+                  action: "Write",
+                  filePath: input.file_path,
+                  content: String(input.content || "").slice(0, MAX_TOOL_CONTENT)
+                };
+              } else {
+                toolUseData = {
+                  action: toolName,
+                  toolName,
+                  input
+                };
+              }
+              this.emit("tool-use", toolUseData);
+            }
+          }
+        }
+      }
+    } else if (message.type === "result") {
+      if (!this.currentAssistantResponse.trim() && "result" in message && message.result) {
+        const resultText = String(message.result);
+        this.emit("output", resultText);
+        this.currentAssistantResponse = resultText;
+      }
+      if (this.currentAssistantResponse.trim()) {
+        this.conversationHistory.push({ role: "assistant", content: this.currentAssistantResponse.trim() });
+      }
+      this.currentAssistantResponse = "";
+      this.isProcessing = false;
+      const queued = this.pendingPrompt;
+      if (queued) {
+        this.pendingPrompt = null;
+        this.sendPrompt(queued.prompt, queued.attachments);
+      } else {
+        this.emit("complete");
+      }
+    } else if (message.type === "tool_progress") {
+      if ("tool_name" in message) {
+        this.emit("output", `
+[Using tool: ${message.tool_name}]
+`);
+      }
+    } else if (message.type === "tool_use_summary") {
+      if ("tool_name" in message) {
+        this.emit("output", `[Tool ${message.tool_name} completed]
+`);
+      }
+    }
+  }
+  async sendPrompt(prompt2, attachments) {
+    if (this.isProcessing) {
+      this.pendingPrompt = { prompt: prompt2, attachments };
+      this.emit("request-queued");
+      return;
+    }
+    this.isProcessing = true;
+    this.currentAssistantResponse = "";
+    if (prompt2.trim()) {
+      this.conversationHistory.push({ role: "user", content: prompt2 });
+    }
+    try {
+      let finalPrompt = prompt2;
+      if (this.pendingContextTransfer && this.conversationHistory.length > 1) {
+        const previousHistory = this.conversationHistory.slice(0, -1);
+        const contextLines = previousHistory.map(
+          (msg) => `${msg.role === "user" ? "User" : "Assistant"}: ${msg.content}`
+        );
+        const contextPrefix = `[Previous conversation context - you switched to a new model]
+${contextLines.join("\n")}
+
+[Continue with new message]
+`;
+        finalPrompt = contextPrefix + prompt2;
+        this.pendingContextTransfer = false;
+      }
+      const session = this.ensureSession();
+      const contentBlocks = [];
+      if (attachments && attachments.length > 0) {
+        for (const attachment of attachments) {
+          contentBlocks.push({
+            type: "image",
+            source: {
+              type: "base64",
+              media_type: attachment.mediaType,
+              data: attachment.data
+            }
+          });
+        }
+      }
+      if (finalPrompt.trim()) {
+        contentBlocks.push({
+          type: "text",
+          text: finalPrompt
+        });
+      }
+      const userMessage = {
+        type: "user",
+        message: {
+          role: "user",
+          content: contentBlocks.length > 0 ? contentBlocks : [{ type: "text", text: finalPrompt }]
+        },
+        parent_tool_use_id: null,
+        session_id: this.sessionId || ""
+      };
+      await session.send(userMessage);
+    } catch (error) {
+      if (error.name === "AbortError") {
+        this.emit("output", "\n[Cancelled]\n");
+      } else {
+        this.emit("error", error);
+        this.emit("output", `
+[Error: ${error.message}]
+`);
+      }
+      this.isProcessing = false;
+    }
+  }
+  /**
+   * Provide an answer to a pending AskUserQuestion.
+   *
+   * AskUserQuestion flows through the canUseTool callback which blocks
+   * waiting for a Promise to resolve.  This method resolves that Promise
+   * with the user's answers, which causes canUseTool to return
+   * {behavior:'allow', updatedInput:{questions, answers}} → the SDK
+   * sends the control_response back to the subprocess → it unblocks and
+   * builds the tool_result for the Claude API.
+   */
+  async provideAnswer(answerText, answers) {
+    if (answerText.trim()) {
+      this.conversationHistory.push({ role: "user", content: answerText });
+    }
+    if (this.pendingAnswerResolve) {
+      const resolvedAnswers = answers || { result: answerText };
+      this.pendingAnswerResolve(resolvedAnswers);
+      this.pendingAnswerResolve = null;
+      return;
+    }
+    await this.sendPrompt(answerText);
+  }
+  cancel() {
+    this.pendingAnswerResolve = null;
+    this.pendingQuestionData = null;
+    this.pendingPermissionData = null;
+    this.pendingPermissionRequests.clear();
+    if (this.v2Session) {
+      this.v2Session.close();
+      this.v2Session = null;
+      this.streamLoopRunning = false;
+    }
+    this.isProcessing = false;
+    this.pendingPrompt = null;
+  }
+  getSessionId() {
+    return this.sessionId;
+  }
+  /**
+   * Resume a different session by setting its ID.
+   * The next sendPrompt call will use this session ID.
+   */
+  resumeSession(sessionId) {
+    if (this.v2Session) {
+      this.v2Session.close();
+      this.v2Session = null;
+      this.streamLoopRunning = false;
+    }
+    this.sessionId = sessionId;
+    this.isProcessing = false;
+    this.pendingPrompt = null;
+    this.conversationHistory = [];
+    this.emit("session-resumed", sessionId);
+  }
+  isActive() {
+    return this.isProcessing;
+  }
+  getPendingQuestionData() {
+    return this.pendingQuestionData;
+  }
+  getPendingPermissionData() {
+    return this.pendingPermissionData;
+  }
+  async setModel(model) {
+    if (model === this.currentModel) return;
+    this.currentModel = model;
+    if (this.v2Session) {
+      this.v2Session.close();
+      this.v2Session = null;
+      this.streamLoopRunning = false;
+      this.sessionId = null;
+      this.isProcessing = false;
+      this.pendingPrompt = null;
+      this.pendingContextTransfer = true;
+    } else if (this.sessionId) {
+      this.sessionId = null;
+      this.pendingContextTransfer = true;
+    }
+    this.emit("model", model);
+  }
+  getModel() {
+    return this.currentModel;
+  }
+  getConversationHistory() {
+    return [...this.conversationHistory];
+  }
+  clearHistory() {
+    this.conversationHistory = [];
+    if (this.v2Session) {
+      this.v2Session.close();
+      this.v2Session = null;
+      this.streamLoopRunning = false;
+    }
+    this.sessionId = null;
+    this.isProcessing = false;
+    this.pendingPrompt = null;
+  }
+  async getSupportedModels() {
+    const coreModels = [
+      { value: "opus", displayName: "Opus 4.6", description: "Opus 4.6 \xB7 Most capable for complex work" },
+      { value: "haiku", displayName: "Haiku 4.5", description: "Haiku 4.5 \xB7 Fastest for quick answers" },
+      { value: "sonnet", displayName: "Sonnet 4.5", description: "Sonnet 4.5 \xB7 Best for everyday tasks" }
+    ];
+    if (this.cachedModels) {
+      return this.cachedModels;
+    }
+    return coreModels;
+  }
+  /**
+   * Scan file system for custom commands/skills
+   * Commands are in ~/.claude/commands/ and .claude/commands/
+   * Subdirectories create namespaced commands (e.g., gsd/add-phase.md -> gsd:add-phase)
+   */
+  scanCustomCommands() {
+    const commands = [];
+    const homeDir = os2.homedir();
+    const dirs = [
+      path.join(homeDir, ".claude", "commands"),
+      // Personal commands
+      path.join(this.options.cwd, ".claude", "commands")
+      // Project commands
+    ];
+    for (const dir of dirs) {
+      if (!fs.existsSync(dir)) continue;
+      try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory()) {
+            const namespace = entry.name;
+            const subDir = path.join(dir, namespace);
+            const subEntries = fs.readdirSync(subDir);
+            for (const file of subEntries) {
+              if (file.endsWith(".md")) {
+                const name = `${namespace}:${file.replace(".md", "")}`;
+                const description = this.extractDescription(path.join(subDir, file));
+                commands.push({ name, description, argumentHint: "" });
+              }
+            }
+          } else if (entry.isFile() && entry.name.endsWith(".md")) {
+            const name = entry.name.replace(".md", "");
+            const description = this.extractDescription(path.join(dir, entry.name));
+            commands.push({ name, description, argumentHint: "" });
+          }
+        }
+      } catch {
+      }
+    }
+    return commands;
+  }
+  /**
+   * Extract description from markdown file (first line or frontmatter)
+   */
+  extractDescription(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, "utf-8");
+      const lines = content.split("\n");
+      if (lines[0] === "---") {
+        for (let i = 1; i < lines.length; i++) {
+          const line = lines[i];
+          if (!line) continue;
+          if (line === "---") break;
+          if (line.startsWith("description:")) {
+            return line.replace("description:", "").trim().replace(/^["']|["']$/g, "");
+          }
+        }
+      }
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("# ")) {
+          return trimmed.replace("# ", "");
+        }
+        if (trimmed && !trimmed.startsWith("---")) {
+          return trimmed.slice(0, 100);
+        }
+      }
+    } catch {
+    }
+    return "";
+  }
+  async getSupportedCommands() {
+    const fallbackCommands = [
+      // Session management
+      { name: "help", description: "Show all commands and custom slash commands", argumentHint: "" },
+      { name: "clear", description: "Clear the conversation history", argumentHint: "" },
+      { name: "compact", description: "Compress conversation by summarizing older messages", argumentHint: "" },
+      { name: "resume", description: "Resume a previous conversation", argumentHint: "<session-id>" },
+      { name: "rewind", description: "Go back to a previous message in the session", argumentHint: "" },
+      { name: "context", description: "Check context and excluded skills", argumentHint: "" },
+      // Configuration
+      { name: "config", description: "Configure Claude Code settings interactively", argumentHint: "" },
+      { name: "permissions", description: "View or update tool permissions", argumentHint: "" },
+      { name: "allowed-tools", description: "Configure tool permissions interactively", argumentHint: "" },
+      { name: "model", description: "Change the AI model", argumentHint: "" },
+      { name: "vim", description: "Enable vim-style editing mode", argumentHint: "" },
+      // Integrations
+      { name: "hooks", description: "Configure hooks", argumentHint: "" },
+      { name: "mcp", description: "Manage MCP servers", argumentHint: "" },
+      { name: "agents", description: "Manage subagents (create, edit, list)", argumentHint: "" },
+      { name: "terminal-setup", description: "Install terminal shortcuts for iTerm2/VS Code", argumentHint: "" },
+      { name: "install-github-app", description: "Set up GitHub Actions integration", argumentHint: "" },
+      { name: "ide", description: "Open in IDE or configure IDE integration", argumentHint: "" },
+      // Project
+      { name: "init", description: "Initialize Claude Code and generate CLAUDE.md", argumentHint: "" },
+      { name: "memory", description: "Edit CLAUDE.md memory file", argumentHint: "" },
+      { name: "add-dir", description: "Add a directory to the context", argumentHint: "<path>" },
+      // Git & Code Review
+      { name: "commit", description: "Commit changes to git with a generated message", argumentHint: "" },
+      { name: "review", description: "Review code changes", argumentHint: "" },
+      { name: "review-pr", description: "Review a GitHub pull request", argumentHint: "<pr-url>" },
+      { name: "pr-comments", description: "Get comments from a GitHub pull request", argumentHint: "" },
+      { name: "release-notes", description: "Generate release notes", argumentHint: "" },
+      { name: "security-review", description: "Perform a security review", argumentHint: "" },
+      // Account & System
+      { name: "login", description: "Log in to your Anthropic account", argumentHint: "" },
+      { name: "logout", description: "Log out of your Anthropic account", argumentHint: "" },
+      { name: "doctor", description: "Check Claude Code health and configuration", argumentHint: "" },
+      { name: "bug", description: "Report a bug to Anthropic", argumentHint: "" },
+      { name: "cost", description: "Show token usage and cost", argumentHint: "" },
+      { name: "status", description: "Show current session status", argumentHint: "" }
+    ];
+    const customCommands = this.scanCustomCommands();
+    let allCommands = [...customCommands];
+    if (this.cachedCommands && this.cachedCommands.length > 0) {
+      const existingNames2 = new Set(allCommands.map((c) => c.name));
+      const newCached = this.cachedCommands.filter((c) => !existingNames2.has(c.name));
+      allCommands = [...allCommands, ...newCached];
+    }
+    const existingNames = new Set(allCommands.map((c) => c.name));
+    const uniqueFallbacks = fallbackCommands.filter((c) => !existingNames.has(c.name));
+    allCommands = [...allCommands, ...uniqueFallbacks];
+    allCommands = allCommands.filter((c) => !UNSUPPORTED_COMMANDS.has(c.name));
+    return allCommands;
+  }
+};
+
+// src/daemon/config-manager.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join3, dirname } from "path";
+import { homedir as homedir3 } from "os";
+var ConfigManager = class {
+  claudeDir;
+  cwd;
+  constructor(options = {}) {
+    const home = options.homeDir || homedir3();
+    this.claudeDir = join3(home, ".claude");
+    this.cwd = options.cwd || process.cwd();
+  }
+  getGlobalSettingsPath() {
+    return join3(this.claudeDir, "settings.json");
+  }
+  getLocalSettingsPath() {
+    return join3(this.claudeDir, "settings.local.json");
+  }
+  getProjectSettingsPath() {
+    return join3(this.cwd, ".claude", "settings.json");
+  }
+  readSettingsFile(path4) {
+    try {
+      if (existsSync3(path4)) {
+        const content = readFileSync3(path4, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch {
+    }
+    return null;
+  }
+  writeSettingsFile(path4, settings) {
+    try {
+      const dir = dirname(path4);
+      if (!existsSync3(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+      writeFileSync2(path4, JSON.stringify(settings, null, 2));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getMergedSettings() {
+    const global = this.readSettingsFile(this.getGlobalSettingsPath()) || {};
+    const local = this.readSettingsFile(this.getLocalSettingsPath()) || {};
+    const project = this.readSettingsFile(this.getProjectSettingsPath()) || {};
+    return {
+      ...global,
+      ...local,
+      ...project,
+      preferences: {
+        ...global.preferences,
+        ...local.preferences,
+        ...project.preferences
+      },
+      permissions: {
+        ...global.permissions,
+        ...local.permissions,
+        ...project.permissions
+      }
+    };
+  }
+  /**
+   * Get the current thinking mode setting from merged settings
+   */
+  getThinkingMode() {
+    const settings = this.getMergedSettings();
+    return settings.alwaysThinkingEnabled ?? false;
+  }
+  getInteractiveData(command) {
+    const settings = this.getMergedSettings();
+    switch (command) {
+      case "config":
+        return this.getConfigData(settings);
+      case "permissions":
+        return this.getPermissionsData(settings);
+      case "vim":
+        return this.getVimData(settings);
+      case "allowed-tools":
+        return this.getAllowedToolsData(settings);
+      default:
+        return {
+          command,
+          uiType: "select",
+          title: `${command} Settings`,
+          description: "This command is not yet supported in mobile.",
+          options: []
+        };
+    }
+  }
+  getConfigData(settings) {
+    const options = [
+      {
+        id: "alwaysThinkingEnabled",
+        label: "Thinking Mode",
+        description: "Enable extended thinking for complex tasks",
+        value: settings.alwaysThinkingEnabled || false,
+        selected: settings.alwaysThinkingEnabled || false
+      },
+      {
+        id: "autoCompact",
+        label: "Auto-Compact",
+        description: "Automatically compact conversation when context is full",
+        value: settings.preferences?.autoCompact ?? true,
+        selected: settings.preferences?.autoCompact ?? true
+      }
+    ];
+    return {
+      command: "config",
+      uiType: "nested",
+      title: "Configuration",
+      description: "Claude Code preferences and settings",
+      options
+    };
+  }
+  getPermissionsData(settings) {
+    const currentMode = settings.permissions?.mode || "default";
+    const options = [
+      {
+        id: "default",
+        label: "Default",
+        description: "Ask before making changes to files",
+        value: "default",
+        selected: currentMode === "default"
+      },
+      {
+        id: "acceptEdits",
+        label: "Auto-approve Edits",
+        description: "Automatically approve file edits",
+        value: "acceptEdits",
+        selected: currentMode === "acceptEdits"
+      },
+      {
+        id: "plan",
+        label: "Plan Mode",
+        description: "Only plan changes without executing",
+        value: "plan",
+        selected: currentMode === "plan"
+      },
+      {
+        id: "bypassPermissions",
+        label: "Yolo Mode",
+        description: "Bypass all permission prompts",
+        value: "bypassPermissions",
+        selected: currentMode === "bypassPermissions"
+      }
+    ];
+    return {
+      command: "permissions",
+      uiType: "select",
+      title: "Permission Mode",
+      description: "Select how Claude handles file edits",
+      options,
+      currentValue: currentMode
+    };
+  }
+  getVimData(settings) {
+    const enabled = settings.vim ?? false;
+    return {
+      command: "vim",
+      uiType: "toggle",
+      title: "Vim Mode",
+      description: "Enable vim keybindings in the editor",
+      options: [
+        {
+          id: "vim-enabled",
+          label: "Vim Mode",
+          description: enabled ? "Currently enabled" : "Currently disabled",
+          value: enabled,
+          selected: enabled
+        }
+      ],
+      currentValue: enabled
+    };
+  }
+  getAllowedToolsData(settings) {
+    const allowedTools = settings.permissions?.allowedTools || [];
+    const allTools = [
+      { id: "Bash", label: "Bash", description: "Execute shell commands" },
+      { id: "Read", label: "Read", description: "Read file contents" },
+      { id: "Write", label: "Write", description: "Write to files" },
+      { id: "Edit", label: "Edit", description: "Edit file contents" },
+      { id: "Glob", label: "Glob", description: "Search for files" },
+      { id: "Grep", label: "Grep", description: "Search file contents" },
+      { id: "WebFetch", label: "WebFetch", description: "Fetch web content" },
+      { id: "WebSearch", label: "WebSearch", description: "Search the web" }
+    ];
+    const options = allTools.map((tool) => ({
+      ...tool,
+      value: tool.id,
+      selected: allowedTools.includes(tool.id)
+    }));
+    return {
+      command: "allowed-tools",
+      uiType: "multi-select",
+      title: "Allowed Tools",
+      description: "Select which tools Claude can use",
+      options,
+      currentValue: allowedTools
+    };
+  }
+  applyChange(payload) {
+    const globalPath = this.getGlobalSettingsPath();
+    const settings = this.readSettingsFile(globalPath) || {};
+    try {
+      switch (payload.command) {
+        case "config":
+          return this.applyConfigChange(settings, globalPath, payload);
+        case "permissions":
+          return this.applyPermissionsChange(settings, globalPath, payload);
+        case "vim":
+          return this.applyVimChange(settings, globalPath, payload);
+        case "allowed-tools":
+          return this.applyAllowedToolsChange(settings, globalPath, payload);
+        default:
+          return {
+            success: false,
+            message: `Unknown command: ${payload.command}`
+          };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  applyConfigChange(settings, path4, payload) {
+    if (!settings.preferences) {
+      settings.preferences = {};
+    }
+    switch (payload.key) {
+      case "theme":
+        settings.preferences.theme = payload.value;
+        break;
+      case "alwaysThinkingEnabled":
+        settings.alwaysThinkingEnabled = payload.value;
+        break;
+      case "autoCompact":
+        settings.preferences.autoCompact = payload.value;
+        break;
+      case "verbose":
+        settings.preferences.verboseMode = payload.value;
+        break;
+      default:
+        return { success: false, message: `Unknown config key: ${payload.key}` };
+    }
+    if (this.writeSettingsFile(path4, settings)) {
+      return { success: true, message: `Config ${payload.key} updated` };
+    }
+    return { success: false, message: "Failed to write settings file" };
+  }
+  applyPermissionsChange(settings, path4, payload) {
+    if (!settings.permissions) {
+      settings.permissions = {};
+    }
+    settings.permissions.mode = payload.value;
+    if (this.writeSettingsFile(path4, settings)) {
+      return { success: true, message: `Permission mode set to ${payload.value}` };
+    }
+    return { success: false, message: "Failed to write settings file" };
+  }
+  applyVimChange(settings, path4, payload) {
+    if (payload.action === "toggle") {
+      settings.vim = !settings.vim;
+    } else {
+      settings.vim = payload.value;
+    }
+    if (this.writeSettingsFile(path4, settings)) {
+      return { success: true, message: `Vim mode ${settings.vim ? "enabled" : "disabled"}` };
+    }
+    return { success: false, message: "Failed to write settings file" };
+  }
+  applyAllowedToolsChange(settings, path4, payload) {
+    if (!settings.permissions) {
+      settings.permissions = {};
+    }
+    if (!settings.permissions.allowedTools) {
+      settings.permissions.allowedTools = [];
+    }
+    const toolId = payload.value;
+    switch (payload.action) {
+      case "add":
+        if (!settings.permissions.allowedTools.includes(toolId)) {
+          settings.permissions.allowedTools.push(toolId);
+        }
+        break;
+      case "remove":
+        settings.permissions.allowedTools = settings.permissions.allowedTools.filter(
+          (t) => t !== toolId
+        );
+        break;
+      case "set":
+        settings.permissions.allowedTools = payload.value;
+        break;
+      case "toggle":
+        if (settings.permissions.allowedTools.includes(toolId)) {
+          settings.permissions.allowedTools = settings.permissions.allowedTools.filter(
+            (t) => t !== toolId
+          );
+        } else {
+          settings.permissions.allowedTools.push(toolId);
+        }
+        break;
+    }
+    if (this.writeSettingsFile(path4, settings)) {
+      return { success: true, message: "Allowed tools updated" };
+    }
+    return { success: false, message: "Failed to write settings file" };
+  }
+};
+
+// src/daemon/daemon.ts
+var Daemon = class extends EventEmitter3 {
+  options;
+  sdkSession;
+  sessionManager;
+  machineManager;
+  configManager;
+  realtimeClient = null;
+  machine = null;
+  session = null;
+  running = false;
+  commandsBroadcast = false;
+  sdkCommandsBroadcast = false;
+  titleSet = false;
+  constructor(options) {
+    super();
+    this.options = options;
+    this.sdkSession = new SdkSession({
+      cwd: options.cwd
+    });
+    this.sessionManager = new SessionManager({
+      supabase: options.supabase
+    });
+    this.machineManager = new MachineManager({
+      supabase: options.supabase
+    });
+    this.configManager = new ConfigManager({
+      cwd: options.cwd
+    });
+    const thinkingEnabled = this.configManager.getThinkingMode();
+    if (thinkingEnabled) {
+      this.sdkSession.setThinkingMode(true);
+    }
+  }
+  async start() {
+    if (this.running) {
+      throw new Error("Daemon is already running");
+    }
+    this.machine = await this.machineManager.registerMachine(
+      this.options.userId,
+      this.options.machineName,
+      this.options.machineId
+    );
+    this.session = await this.sessionManager.createSession(
+      this.machine.id,
+      this.options.cwd
+    );
+    this.realtimeClient = new RealtimeClient({
+      supabase: this.options.supabase,
+      sessionId: this.session.id
+    });
+    this.sdkSession.on("output", async (data) => {
+      if (this.options.hybrid !== false) {
+        process.stdout.write(data);
+      }
+      this.emit("mobile-output", data);
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcast(data);
+        } catch {
+        }
+      }
+    });
+    this.sdkSession.on("error", (error) => {
+      this.emit("error", error);
+    });
+    this.sdkSession.on("commands-updated", async () => {
+      await this.broadcastCommands();
+    });
+    this.sdkSession.on("session-started", async (sdkSessionId) => {
+      if (!this.session) return;
+      try {
+        await this.sessionManager.updateSdkSessionId(this.session.id, sdkSessionId);
+      } catch {
+      }
+    });
+    this.sdkSession.on("complete", async () => {
+      if (this.options.hybrid !== false) {
+        process.stdout.write("\n> ");
+      }
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastComplete();
+        } catch {
+        }
+      }
+      if (!this.sdkCommandsBroadcast && this.realtimeClient) {
+        this.sdkCommandsBroadcast = true;
+        await this.broadcastCommands();
+      }
+    });
+    this.sdkSession.on("permission-mode", async (mode) => {
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastMode(mode);
+        } catch {
+        }
+      }
+    });
+    this.sdkSession.on("user-question", async (questionData) => {
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastUserQuestion(questionData);
+        } catch {
+        }
+      }
+    });
+    this.sdkSession.on("request-queued", async () => {
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastQueued();
+        } catch {
+        }
+      }
+    });
+    this.sdkSession.on("permission-request", async (requestData) => {
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastPermissionRequest(requestData);
+        } catch {
+        }
+      }
+    });
+    this.sdkSession.on("tool-use", async (toolUseData) => {
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastToolUse(toolUseData);
+        } catch (err) {
+          console.warn("[Daemon] Failed to broadcast tool-use:", err);
+        }
+      }
+    });
+    this.sdkSession.on("model", async (model) => {
+      if (this.session) {
+        try {
+          await this.sessionManager.updateSessionModel(this.session.id, model);
+        } catch {
+        }
+      }
+      if (this.realtimeClient) {
+        try {
+          await this.realtimeClient.broadcastModel(model);
+        } catch {
+        }
+      }
+    });
+    this.realtimeClient.on("input", async (message) => {
+      if (!this.commandsBroadcast) {
+        this.commandsBroadcast = true;
+        await this.broadcastCommands();
+      }
+      if (message.type === "mode-change" && message.permissionMode) {
+        this.sdkSession.setPermissionMode(message.permissionMode);
+        if (this.realtimeClient) {
+          try {
+            await this.realtimeClient.broadcastMode(message.permissionMode);
+          } catch {
+          }
+        }
+        return;
+      }
+      if (message.type === "commands-request") {
+        await this.broadcastCommands();
+        return;
+      }
+      if (message.type === "model-change" && message.model) {
+        const previousModel = this.sdkSession.getModel();
+        await this.sdkSession.setModel(message.model);
+        if (previousModel !== message.model) {
+          const modelNames = {
+            "default": "Opus 4.6",
+            "sonnet": "Sonnet 4.5",
+            "opus": "Opus 4.6",
+            "haiku": "Haiku 3.5"
+          };
+          const displayName = modelNames[message.model] || message.model;
+          const confirmationMsg = `[Model switched to ${displayName}]`;
+          if (this.options.hybrid !== false) {
+            process.stdout.write(`
+${confirmationMsg}
+`);
+          }
+          if (this.realtimeClient) {
+            try {
+              await this.realtimeClient.broadcastSystem(confirmationMsg);
+            } catch {
+            }
+          }
+        } else {
+          try {
+            await this.realtimeClient?.broadcastModel(this.sdkSession.getModel());
+          } catch {
+          }
+        }
+        return;
+      }
+      if (message.type === "models-request") {
+        await this.broadcastModels();
+        try {
+          await this.realtimeClient?.broadcastModel(this.sdkSession.getModel());
+        } catch {
+        }
+        return;
+      }
+      if (message.type === "status-request") {
+        if (this.realtimeClient) {
+          try {
+            const pendingQuestion = this.sdkSession.getPendingQuestionData();
+            if (pendingQuestion) {
+              await this.realtimeClient.broadcastUserQuestion(pendingQuestion);
+            }
+            const pendingPermission = this.sdkSession.getPendingPermissionData();
+            if (pendingPermission) {
+              await this.realtimeClient.broadcastPermissionRequest(pendingPermission);
+            }
+          } catch {
+          }
+        }
+        return;
+      }
+      if (message.type === "mobile-disconnect") {
+        if (this.options.hybrid !== false) {
+          process.stdout.write("\n[ClauTunnel] Mobile client disconnected.\n");
+        }
+        this.emit("mobile-disconnected");
+        return;
+      }
+      if (message.type === "interactive-request" && message.interactiveCommand) {
+        const data = this.configManager.getInteractiveData(message.interactiveCommand);
+        if (this.realtimeClient) {
+          try {
+            await this.realtimeClient.broadcastInteractiveResponse(data);
+          } catch {
+          }
+        }
+        return;
+      }
+      if (message.type === "interactive-apply" && message.interactivePayload) {
+        const result = this.configManager.applyChange(message.interactivePayload);
+        if (message.interactivePayload.command === "config" && message.interactivePayload.key === "alwaysThinkingEnabled") {
+          const enabled = Boolean(message.interactivePayload.value);
+          await this.sdkSession.setThinkingMode(enabled);
+        }
+        if (this.realtimeClient) {
+          try {
+            await this.realtimeClient.broadcastInteractiveConfirm(
+              message.interactivePayload.command,
+              result
+            );
+            const statusText = result.success ? `\u2713 ${result.message}` : `\u2717 ${result.message}`;
+            await this.realtimeClient.broadcastSystem(statusText);
+          } catch {
+          }
+        }
+        return;
+      }
+      if (message.type === "cancel-request") {
+        this.sdkSession.cancel();
+        if (this.options.hybrid !== false) {
+          process.stdout.write("\n[Cancelled]\n> ");
+        }
+        if (this.realtimeClient) {
+          try {
+            await this.realtimeClient.broadcastSystem("[Cancelled]");
+            await this.realtimeClient.broadcastComplete();
+          } catch (error) {
+            console.warn("[Daemon] Failed to broadcast cancel:", error);
+          }
+        }
+        return;
+      }
+      if (message.type === "clear-request") {
+        this.sdkSession.clearHistory();
+        if (this.options.hybrid !== false) {
+          process.stdout.write("\n[Conversation cleared]\n> ");
+        }
+        return;
+      }
+      if (message.type === "user-answer" && message.userAnswer) {
+        const answerText = Object.values(message.userAnswer.answers).join("\n");
+        this.emit("mobile-input", `(answer) ${answerText}`);
+        await this.sdkSession.provideAnswer(answerText, message.userAnswer.answers);
+        return;
+      }
+      if (message.type === "permission-response" && message.permissionResponse) {
+        this.sdkSession.handlePermissionResponse(message.permissionResponse);
+        return;
+      }
+      if (message.type === "resume-request" && message.resumeSessionId) {
+        const targetSdkSessionId = message.resumeSessionId;
+        this.sdkSession.resumeSession(targetSdkSessionId);
+        const confirmationMsg = `[Resuming session: ${targetSdkSessionId.slice(0, 8)}...]`;
+        if (this.options.hybrid !== false) {
+          process.stdout.write(`
+${confirmationMsg}
+`);
+        }
+        if (this.realtimeClient) {
+          try {
+            const { data: sessionData } = await this.options.supabase.from("sessions").select("id").eq("sdk_session_id", targetSdkSessionId).single();
+            if (sessionData) {
+              await this.realtimeClient.broadcastResumeHistory(sessionData.id);
+            }
+            await this.realtimeClient.broadcastSystem(confirmationMsg);
+          } catch {
+          }
+        }
+        await this.sdkSession.sendPrompt("Continue from where we left off.");
+        return;
+      }
+      const prompt2 = message.content?.replace(/[\r\n]+$/, "") || "";
+      const attachments = message.attachments;
+      if (prompt2.trim() || attachments && attachments.length > 0) {
+        const trimmedPrompt = prompt2.trim();
+        this.emit("mobile-input", trimmedPrompt, attachments);
+        if (trimmedPrompt === "/clear") {
+          this.sdkSession.clearHistory();
+          if (this.realtimeClient) {
+            try {
+              await this.realtimeClient.broadcastSystem("Conversation cleared");
+            } catch {
+            }
+          }
+          if (this.options.hybrid !== false) {
+            process.stdout.write("\n[Conversation cleared]\n> ");
+          }
+          return;
+        }
+        if (!this.titleSet && this.session) {
+          this.titleSet = true;
+          const title = trimmedPrompt.length > 50 ? trimmedPrompt.slice(0, 50) + "..." : trimmedPrompt;
+          this.sessionManager.updateSessionTitle(this.session.id, title).catch(() => {
+          });
+          if (this.realtimeClient) {
+            this.realtimeClient.broadcastSessionTitle(title).catch(() => {
+            });
+          }
+        }
+        await this.sdkSession.sendPrompt(prompt2, attachments);
+      }
+    });
+    await this.realtimeClient.connect();
+    try {
+      await this.realtimeClient.broadcastMode(this.sdkSession.getPermissionMode());
+    } catch {
+    }
+    await this.broadcastCommands();
+    await this.broadcastModels();
+    try {
+      await this.realtimeClient.broadcastModel(this.sdkSession.getModel());
+    } catch {
+    }
+    this.running = true;
+    this.emit("started", {
+      machine: this.machine,
+      session: this.session,
+      mobileSyncEnabled: this.realtimeClient?.isRealtimeEnabled() ?? false
+    });
+    if (this.options.hybrid !== false) {
+      process.stdout.write("\n[ClauTunnel] Ready for input.\n> ");
+    }
+  }
+  async stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    this.sdkSession.cancel();
+    if (this.session) {
+      await this.sessionManager.endSession(this.session.id);
+    }
+    if (this.realtimeClient) {
+      await this.realtimeClient.disconnect();
+    }
+    this.emit("stopped");
+  }
+  async sendPrompt(prompt2, attachments) {
+    await this.sdkSession.sendPrompt(prompt2, attachments);
+  }
+  isRunning() {
+    return this.running;
+  }
+  getSession() {
+    return this.session;
+  }
+  getMachine() {
+    return this.machine;
+  }
+  async broadcastCommands() {
+    if (!this.realtimeClient) {
+      return;
+    }
+    try {
+      const commands = await this.sdkSession.getSupportedCommands();
+      await this.realtimeClient.broadcastCommands(commands);
+    } catch {
+    }
+  }
+  async broadcastModels() {
+    if (!this.realtimeClient) {
+      return;
+    }
+    try {
+      const models = await this.sdkSession.getSupportedModels();
+      await this.realtimeClient.broadcastModels(models);
+    } catch {
+    }
+  }
+};
+
+// src/index.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/start.ts
+import { Command } from "commander";
+import WebSocket from "ws";
+
+// src/realtime/machine-client.ts
+var import_clautunnel_shared2 = __toESM(require_dist(), 1);
+import { EventEmitter as EventEmitter4 } from "events";
+var MachineRealtimeClient = class extends EventEmitter4 {
+  supabase;
+  machineId;
+  inputChannel = null;
+  outputChannel = null;
+  presenceChannel = null;
+  constructor(options) {
+    super();
+    this.supabase = options.supabase;
+    this.machineId = options.machineId;
+  }
+  async connect() {
+    const inputChannelName = import_clautunnel_shared2.REALTIME_CHANNELS.machineInput(this.machineId);
+    this.inputChannel = this.supabase.channel(inputChannelName);
+    this.inputChannel.on("broadcast", { event: "machine-command" }, (payload) => {
+      this.emit("command", payload.payload);
+    });
+    const outputChannelName = import_clautunnel_shared2.REALTIME_CHANNELS.machineOutput(this.machineId);
+    this.outputChannel = this.supabase.channel(outputChannelName);
+    const results = await Promise.all([
+      subscribeWithTimeout(this.inputChannel, "machine-input"),
+      subscribeWithTimeout(this.outputChannel, "machine-output")
+    ]);
+    const connected = results.every((success) => success);
+    if (connected) {
+      const presenceChannelName = import_clautunnel_shared2.REALTIME_CHANNELS.machinePresence(this.machineId);
+      this.presenceChannel = this.supabase.channel(presenceChannelName);
+      this.presenceChannel.subscribe(async (status) => {
+        if (status === "SUBSCRIBED" && this.presenceChannel) {
+          try {
+            const payload = {
+              type: "cli",
+              online_at: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            await this.presenceChannel.track(payload);
+          } catch (trackError) {
+            console.warn("[WARN] Failed to track machine presence:", trackError);
+          }
+        }
+      });
+    }
+    return connected;
+  }
+  async broadcastSessionStarted(sessionId, workingDirectory) {
+    if (!this.outputChannel) return;
+    const command = {
+      type: "session-started",
+      sessionId,
+      workingDirectory,
+      timestamp: Date.now()
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "machine-command",
+      payload: command
+    });
+  }
+  async broadcastSessionEnded(sessionId) {
+    if (!this.outputChannel) return;
+    const command = {
+      type: "session-ended",
+      sessionId,
+      timestamp: Date.now()
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "machine-command",
+      payload: command
+    });
+  }
+  async broadcastError(error) {
+    if (!this.outputChannel) return;
+    const command = {
+      type: "start-session-error",
+      error,
+      timestamp: Date.now()
+    };
+    await this.outputChannel.send({
+      type: "broadcast",
+      event: "machine-command",
+      payload: command
+    });
+  }
+  async disconnect() {
+    if (this.presenceChannel) {
+      await this.presenceChannel.untrack();
+      await this.supabase.removeChannel(this.presenceChannel);
+      this.presenceChannel = null;
+    }
+    if (this.inputChannel) {
+      await this.supabase.removeChannel(this.inputChannel);
+      this.inputChannel = null;
+    }
+    if (this.outputChannel) {
+      await this.supabase.removeChannel(this.outputChannel);
+      this.outputChannel = null;
+    }
+    this.emit("disconnected");
+  }
+};
+
+// src/utils/spinner.ts
+var Spinner = class {
+  frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+  currentFrame = 0;
+  interval = null;
+  message;
+  stream;
+  constructor(message, stream = process.stdout) {
+    this.message = message;
+    this.stream = stream;
+  }
+  start() {
+    if (this.interval) {
+      return;
+    }
+    this.stream.write("\x1B[?25l");
+    this.interval = setInterval(() => {
+      const frame = this.frames[this.currentFrame];
+      this.stream.write(`\r${frame} ${this.message}`);
+      this.currentFrame = (this.currentFrame + 1) % this.frames.length;
+    }, 80);
+  }
+  update(message) {
+    this.message = message;
+  }
+  stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    this.stream.write("\r\x1B[K");
+    this.stream.write("\x1B[?25h");
+  }
+  succeed(message) {
+    this.stop();
+    this.stream.write(`\r\u2713 ${message}
+`);
+  }
+  fail(message) {
+    this.stop();
+    this.stream.write(`\r\u2717 ${message}
+`);
+  }
+};
+
+// src/utils/supabase.ts
+import { createClient } from "@supabase/supabase-js";
+function createSupabaseClient(url, anonKey, options) {
+  const clientOptions = options?.realtime ? {
+    realtime: {
+      params: { eventsPerSecond: 10 },
+      timeout: 3e4
+    }
+  } : void 0;
+  return createClient(url, anonKey, clientOptions);
+}
+async function restoreSession(supabase, config2) {
+  const sessionTokens = config2.getSessionTokens();
+  if (!sessionTokens) {
+    return null;
+  }
+  const { error: sessionError } = await supabase.auth.setSession({
+    access_token: sessionTokens.accessToken,
+    refresh_token: sessionTokens.refreshToken
+  });
+  if (sessionError) {
+    config2.clearSessionTokens();
+    return null;
+  }
+  const {
+    data: { user },
+    error: authError
+  } = await supabase.auth.getUser();
+  if (authError || !user) {
+    return null;
+  }
+  return { user };
+}
+
+// src/utils/sleep-prevention.ts
+import { spawn, execSync } from "child_process";
+import * as readline from "readline";
+import { readdirSync as readdirSync2 } from "fs";
+import * as path2 from "path";
+import * as os3 from "os";
+async function promptYesNo(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+    });
+  });
+}
+function enableSleepPrevention() {
+  try {
+    execSync("sudo pmset -a disablesleep 1", { stdio: "inherit" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function disableSleepPrevention() {
+  try {
+    execSync("sudo pmset -a disablesleep 0", { stdio: "inherit" });
+  } catch {
+  }
+}
+function startCaffeinate() {
+  const process2 = spawn("caffeinate", ["-i", "-s"], {
+    stdio: "ignore",
+    detached: false
+  });
+  return process2;
+}
+function stopCaffeinate(process2) {
+  if (process2) {
+    process2.kill();
+  }
+}
+function cleanup(state) {
+  stopCaffeinate(state.caffeinateProcess);
+  if (state.pmsetEnabled) {
+    disableSleepPrevention();
+  }
+}
+function isMacOS() {
+  return process.platform === "darwin";
+}
+function checkFullDiskAccess() {
+  if (!isMacOS()) return true;
+  try {
+    const safariDir = path2.join(os3.homedir(), "Library", "Safari");
+    readdirSync2(safariDir);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var TERM_PROGRAM_MAP = {
+  vscode: "Visual Studio Code",
+  Apple_Terminal: "Terminal",
+  "iTerm.app": "iTerm2",
+  WarpTerminal: "Warp",
+  Hyper: "Hyper"
+};
+function getTerminalAppName() {
+  const termProgram = process.env.TERM_PROGRAM;
+  if (termProgram && TERM_PROGRAM_MAP[termProgram]) {
+    return TERM_PROGRAM_MAP[termProgram];
+  }
+  return "your terminal app";
+}
+function openFullDiskAccessSettings() {
+  if (!isMacOS()) return false;
+  try {
+    execSync(
+      'open "x-apple.systempreferences:com.apple.preference.security?Privacy_AllFiles"'
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getFullDiskAccessStatus(enabled, terminalApp) {
+  if (enabled) {
+    return {
+      enabled: true,
+      label: "Enabled"
+    };
+  }
+  const appName = terminalApp || "your terminal app";
+  return {
+    enabled: false,
+    label: "Not enabled",
+    warning: [
+      "Without Full Disk Access, macOS may show permission dialogs",
+      "when Claude tries to access certain files or directories.",
+      "These dialogs are only visible on this machine's screen \u2014",
+      "you won't be able to see or approve them from the mobile app,",
+      "which will cause Claude's operations to silently hang.",
+      "",
+      "To enable:",
+      `  1. Open System Settings \u2192 Privacy & Security \u2192 Full Disk Access`,
+      `  2. Toggle ON "${appName}" in the list`,
+      '  3. Restart your terminal and run "clautunnel start" again'
+    ].join("\n")
+  };
+}
+
+// src/commands/start.ts
+if (typeof globalThis.WebSocket === "undefined") {
+  globalThis.WebSocket = WebSocket;
+}
+function createStartCommand() {
+  const command = new Command("start");
+  command.description("Start ClauTunnel and listen for session requests from mobile app").option("-n, --name <name>", "Machine name").option("--prevent-sleep", "Auto-enable sleep prevention (skip prompt)").action(async (options) => {
+    const config2 = new Config();
+    const logger = new Logger();
+    const spinner = new Spinner("Starting ClauTunnel...");
+    const daemons = /* @__PURE__ */ new Map();
+    let machineClient = null;
+    try {
+      config2.requireConfiguration();
+      spinner.start();
+      const supabase = createSupabaseClient(
+        config2.getSupabaseUrl(),
+        config2.getSupabaseAnonKey(),
+        { realtime: true }
+      );
+      spinner.update("Authenticating...");
+      const session = await restoreSession(supabase, config2);
+      if (!session) {
+        spinner.fail("Not authenticated");
+        logger.error('Run "clautunnel login" first.');
+        process.exit(1);
+      }
+      const { user } = session;
+      let fdaStatus = null;
+      if (isMacOS()) {
+        spinner.stop();
+        const terminalApp = getTerminalAppName();
+        let fdaEnabled = checkFullDiskAccess();
+        fdaStatus = getFullDiskAccessStatus(fdaEnabled, terminalApp);
+        if (fdaStatus.enabled) {
+          logger.info(`\u2713 Full Disk Access: ${fdaStatus.label}`);
+        } else {
+          logger.warn(`\u26A0 Full Disk Access: ${fdaStatus.label}`);
+          logger.warn("");
+          for (const line of fdaStatus.warning.split("\n")) {
+            logger.warn(`  ${line}`);
+          }
+          logger.warn("");
+          const openSettings = await promptYesNo(
+            "Open Full Disk Access settings? [Y/n]: "
+          );
+          if (openSettings) {
+            openFullDiskAccessSettings();
+            logger.info("");
+            await promptYesNo(
+              "Press Enter after enabling Full Disk Access (or Enter to skip): "
+            );
+            fdaEnabled = checkFullDiskAccess();
+            fdaStatus = getFullDiskAccessStatus(fdaEnabled, terminalApp);
+            if (fdaStatus.enabled) {
+              logger.info("\u2713 Full Disk Access: Enabled");
+            } else {
+              logger.warn("Full Disk Access still not enabled. Continuing without it.");
+            }
+          }
+          logger.info("");
+        }
+        spinner.start();
+      }
+      const sleepState = {
+        caffeinateProcess: null,
+        pmsetEnabled: false
+      };
+      if (isMacOS()) {
+        spinner.stop();
+        const enableSleep = options.preventSleep || await promptYesNo(
+          "Prevent sleep when lid is closed? (keeps clautunnel running) [y/N]: "
+        );
+        if (enableSleep) {
+          logger.info("");
+          logger.info("Enabling sleep prevention...");
+          if (!options.preventSleep) {
+            logger.info("This requires sudo password (auto-restored on exit)");
+            logger.info("");
+          }
+          sleepState.pmsetEnabled = enableSleepPrevention();
+          if (sleepState.pmsetEnabled) {
+            logger.info("\u2713 Lid-closed mode enabled");
+          } else {
+            logger.warn("Failed to enable lid-closed mode. Using basic mode.");
+          }
+          sleepState.caffeinateProcess = startCaffeinate();
+          sleepState.caffeinateProcess.on("error", () => {
+            logger.warn("Failed to start caffeinate");
+          });
+          logger.info("");
+        }
+        spinner.start();
+      }
+      const cleanup2 = () => {
+        if (sleepState.pmsetEnabled) {
+          console.log("Restoring sleep settings...");
+        }
+        cleanup(sleepState);
+      };
+      let isShuttingDown = false;
+      const gracefulShutdown = async (signal) => {
+        if (isShuttingDown) {
+          console.log("\nForce exiting...");
+          process.exit(1);
+        }
+        isShuttingDown = true;
+        console.log(`
+[${signal}] Shutting down gracefully...`);
+        try {
+          for (const [sessionId, d] of daemons) {
+            try {
+              await d.stop();
+            } catch {
+            }
+            daemons.delete(sessionId);
+          }
+          if (machineClient) {
+            await machineClient.disconnect();
+            machineClient = null;
+          }
+          console.log("[Cleanup] All sessions ended in database");
+          await cleanup2();
+        } catch (error) {
+          console.error("[Cleanup] Error during shutdown:", error);
+        }
+        process.exit(0);
+      };
+      process.on("SIGINT", () => {
+        gracefulShutdown("SIGINT").catch(console.error);
+      });
+      process.on("SIGTERM", () => {
+        gracefulShutdown("SIGTERM").catch(console.error);
+      });
+      spinner.update("Registering machine...");
+      const machineManager = new MachineManager({ supabase });
+      const machine = await machineManager.registerMachine(
+        user.id,
+        options.name,
+        config2.getMachineId()
+      );
+      config2.setMachineId(machine.id);
+      spinner.update("Connecting to realtime...");
+      machineClient = new MachineRealtimeClient({
+        supabase,
+        machineId: machine.id
+      });
+      const connected = await machineClient.connect();
+      spinner.stop();
+      if (!connected) {
+        logger.error(
+          "Failed to connect to realtime. Check your network connection."
+        );
+        process.exit(1);
+      }
+      logger.info("");
+      logger.info("\u2713 ClauTunnel is ready!");
+      logger.info(`  Machine: ${machine.name}`);
+      if (fdaStatus) {
+        if (fdaStatus.enabled) {
+          logger.info(`  Full Disk Access: ${fdaStatus.label}`);
+        } else {
+          logger.warn(`  Full Disk Access: ${fdaStatus.label}`);
+        }
+      }
+      if (sleepState.caffeinateProcess) {
+        logger.info(
+          `  Sleep prevention: ${sleepState.pmsetEnabled ? "Lid-closed mode" : "Basic mode"}`
+        );
+      }
+      logger.info("");
+      logger.info("Open the mobile app to start a session.");
+      logger.info("Press Ctrl+C to stop.");
+      logger.info("");
+      machineClient.on("command", async (cmd) => {
+        if (cmd.type === "start-session") {
+          logger.info("Starting session (requested from mobile)...");
+          try {
+            const newDaemon = new Daemon({
+              supabase,
+              userId: user.id,
+              machineId: machine.id,
+              machineName: options.name,
+              cwd: process.cwd(),
+              hybrid: false
+            });
+            newDaemon.on("started", async ({ session: session2 }) => {
+              daemons.set(session2.id, newDaemon);
+              logger.info(`  Session: ${session2.id.slice(0, 8)}...`);
+              logger.info("  Mobile sync: Enabled");
+              logger.info(`  Active sessions: ${daemons.size}`);
+              logger.info("");
+              await machineClient?.broadcastSessionStarted(
+                session2.id,
+                process.cwd()
+              );
+            });
+            newDaemon.on("error", (error) => {
+              logger.error(`Session error: ${error.message}`);
+            });
+            newDaemon.on("mobile-input", (prompt2, attachments) => {
+              const hasImages = attachments && attachments.length > 0;
+              const imageInfo = hasImages ? ` [+${attachments.length} image${attachments.length > 1 ? "s" : ""}]` : "";
+              logger.info(`[Mobile] ${prompt2}${imageInfo}`);
+            });
+            newDaemon.on("mobile-output", (data) => {
+              const trimmed = data.trim();
+              if (trimmed) {
+                logger.info(`[Claude] ${trimmed}`);
+              }
+            });
+            newDaemon.on("mobile-disconnected", async () => {
+              logger.info("Mobile disconnected. Ending session...");
+              try {
+                await newDaemon.stop();
+              } catch {
+              }
+            });
+            newDaemon.on("stopped", async () => {
+              const sessionId = newDaemon.getSession()?.id;
+              if (sessionId) {
+                daemons.delete(sessionId);
+                await machineClient?.broadcastSessionEnded(sessionId);
+              }
+              logger.info("Session ended.");
+              logger.info(`  Active sessions: ${daemons.size}`);
+              logger.info("");
+              if (daemons.size === 0) {
+                logger.info("Waiting for next session request...");
+                logger.info("");
+              }
+            });
+            await newDaemon.start();
+          } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            logger.error(`Failed to start session: ${errorMessage}`);
+            await machineClient?.broadcastError(errorMessage);
+          }
+        }
+        if (cmd.type === "stop-session" && cmd.sessionId) {
+          const targetDaemon = daemons.get(cmd.sessionId);
+          if (targetDaemon) {
+            logger.info(`Stopping session ${cmd.sessionId.slice(0, 8)}... (requested from mobile)`);
+            try {
+              await targetDaemon.stop();
+            } catch {
+            }
+          }
+        }
+      });
+    } catch (error) {
+      if (error instanceof ConfigurationError) {
+        spinner.stop();
+        logger.error(error.message);
+        process.exit(1);
+      }
+      spinner.fail("Failed to start");
+      logger.error(
+        `${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/stop.ts
+import { Command as Command2 } from "commander";
+import * as fs2 from "fs";
+import * as path3 from "path";
+import * as os4 from "os";
+var PID_FILE = path3.join(os4.homedir(), ".clautunnel", "daemon.pid");
+function createStopCommand() {
+  const command = new Command2("stop");
+  command.description("Stop the running daemon").action(async () => {
+    const logger = new Logger();
+    try {
+      if (!fs2.existsSync(PID_FILE)) {
+        logger.info("No daemon is running");
+        return;
+      }
+      const pid = parseInt(fs2.readFileSync(PID_FILE, "utf-8").trim(), 10);
+      if (isNaN(pid)) {
+        logger.error("Invalid PID file");
+        fs2.unlinkSync(PID_FILE);
+        return;
+      }
+      try {
+        process.kill(pid, 0);
+        process.kill(pid, "SIGTERM");
+        logger.info(`Sent stop signal to daemon (PID: ${pid})`);
+        let attempts = 0;
+        while (attempts < 10) {
+          await new Promise((resolve2) => setTimeout(resolve2, 500));
+          try {
+            process.kill(pid, 0);
+            attempts++;
+          } catch {
+            break;
+          }
+        }
+        if (attempts >= 10) {
+          logger.warn("Daemon did not stop gracefully, sending SIGKILL");
+          process.kill(pid, "SIGKILL");
+        }
+        logger.info("Daemon stopped");
+      } catch (err) {
+        if (err.code === "ESRCH") {
+          logger.info("Daemon process not found (already stopped)");
+        } else {
+          throw err;
+        }
+      }
+      if (fs2.existsSync(PID_FILE)) {
+        fs2.unlinkSync(PID_FILE);
+      }
+    } catch (error) {
+      logger.error(
+        `Failed to stop daemon: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/status.ts
+import { Command as Command3 } from "commander";
+function createStatusCommand() {
+  const command = new Command3("status");
+  command.description("Show connection status").action(async () => {
+    const config2 = new Config();
+    const logger = new Logger();
+    try {
+      const supabase = createSupabaseClient(
+        config2.getSupabaseUrl(),
+        config2.getSupabaseAnonKey()
+      );
+      const session = await restoreSession(supabase, config2);
+      if (!session) {
+        logger.info("Status: Not authenticated");
+        logger.info('Run "clautunnel login" to authenticate');
+        return;
+      }
+      const { user } = session;
+      logger.info(`User: ${user.email}`);
+      const machineId = config2.getMachineId();
+      if (!machineId) {
+        logger.info("Machine: Not registered");
+        logger.info('Run "clautunnel start" to register this machine');
+        return;
+      }
+      const machineManager = new MachineManager({ supabase });
+      const machine = await machineManager.getMachine(machineId);
+      if (!machine) {
+        logger.info(`Machine ID: ${machineId} (not found)`);
+        return;
+      }
+      logger.info(`Machine: ${machine.name} (${machine.id})`);
+      logger.info(`Status: ${machine.status}`);
+      logger.info(`Last seen: ${machine.last_seen_at}`);
+    } catch (error) {
+      logger.error(
+        `Failed to get status: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/login.ts
+import { Command as Command4 } from "commander";
+
+// src/utils/prompt.ts
+import * as readline2 from "readline";
+function prompt(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer);
+    });
+  });
+}
+function promptHidden(question) {
+  const rl = readline2.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    process.stdout.write(question);
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(true);
+    }
+    let password = "";
+    const onData = (char) => {
+      const c = char.toString();
+      if (c === "\n" || c === "\r") {
+        process.stdin.removeListener("data", onData);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        process.stdout.write("\n");
+        rl.close();
+        resolve2(password);
+      } else if (c === "") {
+        process.exit(0);
+      } else if (c === "\x7F" || c === "\b") {
+        if (password.length > 0) {
+          password = password.slice(0, -1);
+        }
+      } else {
+        password += c;
+      }
+    };
+    process.stdin.on("data", onData);
+    process.stdin.resume();
+  });
+}
+
+// src/commands/login.ts
+function createLoginCommand() {
+  const command = new Command4("login");
+  command.description("Authenticate with ClauTunnel").action(async () => {
+    const config2 = new Config();
+    const logger = new Logger();
+    try {
+      config2.requireConfiguration();
+      const supabase = createSupabaseClient(
+        config2.getSupabaseUrl(),
+        config2.getSupabaseAnonKey()
+      );
+      const email = await prompt("Email: ");
+      const password = await promptHidden("Password: ");
+      if (!email || !password) {
+        logger.error("Email and password are required");
+        process.exit(1);
+      }
+      const { data, error } = await supabase.auth.signInWithPassword({
+        email,
+        password
+      });
+      if (error) {
+        logger.error(`Login failed: ${error.message}`);
+        process.exit(1);
+      }
+      if (data.user) {
+        logger.info(`Logged in as ${data.user.email}`);
+        if (data.session) {
+          config2.setSession({
+            accessToken: data.session.access_token,
+            refreshToken: data.session.refresh_token
+          });
+          logger.info("Session saved");
+        }
+      }
+    } catch (error) {
+      if (error instanceof ConfigurationError) {
+        logger.error(error.message);
+        process.exit(1);
+      }
+      logger.error(
+        `Login failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/commands/setup.ts
+import { Command as Command5 } from "commander";
+function createSetupCommand() {
+  const command = new Command5("setup");
+  command.description("Configure ClauTunnel with Supabase credentials").action(async () => {
+    const config2 = new Config();
+    const logger = new Logger();
+    try {
+      logger.info("ClauTunnel Setup");
+      logger.info("================");
+      logger.info("");
+      logger.info("Enter your Supabase credentials to connect ClauTunnel.");
+      logger.info("");
+      logger.info("To find your credentials:");
+      logger.info("  1. Go to your Supabase project dashboard");
+      logger.info('  2. Settings > General > Copy "Project URL"');
+      logger.info('  3. Settings > API Keys > Copy "anon public" key');
+      logger.info("");
+      const url = await prompt("Supabase Project URL (e.g., https://xxxx.supabase.co): ");
+      if (!url) {
+        logger.error("Supabase URL is required");
+        process.exit(1);
+      }
+      try {
+        const parsedUrl = new URL(url);
+        if (parsedUrl.hostname === "supabase.com") {
+          logger.error("");
+          logger.error("This looks like a dashboard URL, not the API URL.");
+          logger.error("");
+          logger.error("Please use the Project URL from Settings > API, which looks like:");
+          logger.error("  https://your-project-id.supabase.co");
+          logger.error("");
+          logger.error("NOT the dashboard URL:");
+          logger.error("  https://supabase.com/dashboard/project/...");
+          process.exit(1);
+        }
+        if (!parsedUrl.hostname.endsWith(".supabase.co")) {
+          logger.error("");
+          logger.error("Invalid Supabase URL format.");
+          logger.error("The URL should end with .supabase.co");
+          logger.error("Example: https://your-project-id.supabase.co");
+          process.exit(1);
+        }
+      } catch {
+        logger.error("Invalid URL format. Please enter a valid URL (e.g., https://xxxx.supabase.co)");
+        process.exit(1);
+      }
+      const anonKey = await prompt("Supabase Anon Key: ");
+      if (!anonKey) {
+        logger.error("Supabase Anon Key is required");
+        process.exit(1);
+      }
+      config2.setSupabaseCredentials({ url, anonKey });
+      logger.info("");
+      logger.info("\u2713 Configuration saved successfully!");
+      logger.info("");
+      logger.info("Next steps:");
+      logger.info('  1. Run "clautunnel login" to authenticate');
+      logger.info('  2. Run "clautunnel start" to begin a session');
+    } catch (error) {
+      logger.error(
+        `Setup failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      process.exit(1);
+    }
+  });
+  return command;
+}
+
+// src/index.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname2(__filename);
+config({ path: resolve(__dirname, "../.env"), quiet: true });
+var packageJson = JSON.parse(
+  readFileSync5(resolve(__dirname, "../package.json"), "utf-8")
+);
+var version = packageJson.version || "0.0.0";
+var program = new Command6();
+program.name("clautunnel").description("Remote control for Claude Code CLI").version(version);
+program.addCommand(createSetupCommand());
+program.addCommand(createStartCommand());
+program.addCommand(createStopCommand());
+program.addCommand(createStatusCommand());
+program.addCommand(createLoginCommand());
+if (process.argv[1]?.includes("clautunnel") || process.argv[1]?.endsWith("/index.js") || process.argv[1]?.endsWith("/index.ts")) {
+  program.parse();
+}
+export {
+  Config,
+  Daemon,
+  Logger,
+  MachineManager,
+  RealtimeClient,
+  SessionManager,
+  getConfig,
+  getLogger
+};
+//# sourceMappingURL=index.js.map