episoda 0.2.15 → 0.2.17

package/dist/index.js

@@ -1489,15 +1489,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs5 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs6 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs5.access(rebaseMergePath);
+              await fs6.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs5.access(rebaseApplyPath);
+                await fs6.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -2115,34 +2115,34 @@ var require_auth = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.getConfigDir = getConfigDir4;
     exports2.getConfigPath = getConfigPath3;
-    exports2.loadConfig = loadConfig3;
+    exports2.loadConfig = loadConfig4;
     exports2.saveConfig = saveConfig3;
     exports2.validateToken = validateToken;
-    var fs5 = __importStar(require("fs"));
-    var path7 = __importStar(require("path"));
-    var os2 = __importStar(require("os"));
+    var fs6 = __importStar(require("fs"));
+    var path8 = __importStar(require("path"));
+    var os3 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir4() {
-      return process.env.EPISODA_CONFIG_DIR || path7.join(os2.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path8.join(os3.homedir(), ".episoda");
     }
     function getConfigPath3(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path7.join(getConfigDir4(), DEFAULT_CONFIG_FILE);
+      return path8.join(getConfigDir4(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path7.dirname(configPath);
-      const isNew = !fs5.existsSync(dir);
+      const dir = path8.dirname(configPath);
+      const isNew = !fs6.existsSync(dir);
       if (isNew) {
-        fs5.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs6.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path7.join(dir, ".nosync");
-        if (isNew || !fs5.existsSync(nosyncPath)) {
+        const nosyncPath = path8.join(dir, ".nosync");
+        if (isNew || !fs6.existsSync(nosyncPath)) {
           try {
-            fs5.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs6.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2152,13 +2152,13 @@ var require_auth = __commonJS({
         }
       }
     }
-    async function loadConfig3(configPath) {
+    async function loadConfig4(configPath) {
       const fullPath = getConfigPath3(configPath);
-      if (!fs5.existsSync(fullPath)) {
+      if (!fs6.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs5.readFileSync(fullPath, "utf8");
+        const content = fs6.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2171,7 +2171,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs5.writeFileSync(fullPath, content, { mode: 384 });
+        fs6.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2277,7 +2277,7 @@ var require_dist = __commonJS({
 
 // src/index.ts
 var import_commander = require("commander");
-var import_core7 = __toESM(require_dist());
+var import_core8 = __toESM(require_dist());
 
 // src/commands/dev.ts
 var import_core3 = __toESM(require_dist());
@@ -2676,12 +2676,12 @@ async function sendCommand(command, params, timeout = DEFAULT_TIMEOUT) {
       reject(new Error(`Command timed out after ${timeout}ms`));
     }, timeout);
     socket.on("connect", () => {
-      const request = {
+      const request2 = {
         id: requestId,
         command,
         params
       };
-      socket.write(JSON.stringify(request) + "\n");
+      socket.write(JSON.stringify(request2) + "\n");
     });
     socket.on("data", (chunk) => {
       buffer += chunk.toString();
@@ -3601,10 +3601,10 @@ async function exchangeDeviceCode(apiUrl, deviceCode, machineId) {
   return tokenResponse;
 }
 function openBrowser(url) {
-  const platform2 = os.platform();
+  const platform3 = os.platform();
   let command;
   let args;
-  switch (platform2) {
+  switch (platform3) {
     case "darwin":
       command = "open";
       args = [url];
@@ -3661,8 +3661,8 @@ async function installGitCredentialHelper(apiUrl) {
   }
 }
 function updateShellProfile(binDir) {
-  const platform2 = os.platform();
-  if (platform2 === "win32") {
+  const platform3 = os.platform();
+  if (platform3 === "win32") {
     return;
   }
   const homeDir = os.homedir();
@@ -3817,8 +3817,634 @@ async function stopCommand(options = {}) {
   }
 }
 
+// src/commands/tunnel.ts
+var import_core7 = __toESM(require_dist());
+
+// src/tunnel/cloudflared-manager.ts
+var import_child_process5 = require("child_process");
+var fs5 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var os2 = __toESM(require("os"));
+var https = __toESM(require("https"));
+var tar = __toESM(require("tar"));
+var DOWNLOAD_URLS = {
+  darwin: {
+    arm64: "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-arm64.tgz",
+    x64: "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-darwin-amd64.tgz"
+  },
+  linux: {
+    arm64: "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-arm64",
+    x64: "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-linux-amd64"
+  },
+  win32: {
+    x64: "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-amd64.exe",
+    ia32: "https://github.com/cloudflare/cloudflared/releases/latest/download/cloudflared-windows-386.exe"
+  }
+};
+function getEpisodaBinDir() {
+  return path7.join(os2.homedir(), ".episoda", "bin");
+}
+function getCloudflaredPath() {
+  const binaryName = os2.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+  return path7.join(getEpisodaBinDir(), binaryName);
+}
+function isCloudflaredInPath() {
+  try {
+    const command = os2.platform() === "win32" ? "where" : "which";
+    const binaryName = os2.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+    const result = (0, import_child_process5.spawnSync)(command, [binaryName], { encoding: "utf-8" });
+    if (result.status === 0 && result.stdout.trim()) {
+      return result.stdout.trim().split("\n")[0].trim();
+    }
+  } catch {
+  }
+  return null;
+}
+function isCloudflaredInstalled() {
+  const cloudflaredPath = getCloudflaredPath();
+  try {
+    fs5.accessSync(cloudflaredPath, fs5.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function verifyCloudflared(binaryPath) {
+  try {
+    const result = (0, import_child_process5.spawnSync)(binaryPath, ["version"], { encoding: "utf-8", timeout: 5e3 });
+    return result.status === 0 && result.stdout.includes("cloudflared");
+  } catch {
+    return false;
+  }
+}
+function getDownloadUrl() {
+  const platform3 = os2.platform();
+  const arch2 = os2.arch();
+  const platformUrls = DOWNLOAD_URLS[platform3];
+  if (!platformUrls) {
+    return null;
+  }
+  return platformUrls[arch2] || null;
+}
+async function downloadFile(url, destPath) {
+  return new Promise((resolve2, reject) => {
+    const followRedirect = (currentUrl, redirectCount = 0) => {
+      if (redirectCount > 5) {
+        reject(new Error("Too many redirects"));
+        return;
+      }
+      const urlObj = new URL(currentUrl);
+      const options = {
+        hostname: urlObj.hostname,
+        path: urlObj.pathname + urlObj.search,
+        headers: {
+          "User-Agent": "episoda-cli"
+        }
+      };
+      https.get(options, (response) => {
+        if (response.statusCode === 301 || response.statusCode === 302) {
+          const redirectUrl = response.headers.location;
+          if (redirectUrl) {
+            followRedirect(redirectUrl, redirectCount + 1);
+            return;
+          }
+        }
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to download: HTTP ${response.statusCode}`));
+          return;
+        }
+        const file = fs5.createWriteStream(destPath);
+        response.pipe(file);
+        file.on("finish", () => {
+          file.close();
+          resolve2();
+        });
+        file.on("error", (err) => {
+          fs5.unlinkSync(destPath);
+          reject(err);
+        });
+      }).on("error", reject);
+    };
+    followRedirect(url);
+  });
+}
+async function extractTgz(archivePath, destDir) {
+  return tar.x({
+    file: archivePath,
+    cwd: destDir
+  });
+}
+async function downloadCloudflared() {
+  const url = getDownloadUrl();
+  if (!url) {
+    throw new Error(`Unsupported platform: ${os2.platform()} ${os2.arch()}`);
+  }
+  const binDir = getEpisodaBinDir();
+  const cloudflaredPath = getCloudflaredPath();
+  fs5.mkdirSync(binDir, { recursive: true });
+  const isTgz = url.endsWith(".tgz");
+  if (isTgz) {
+    const tempFile = path7.join(binDir, "cloudflared.tgz");
+    console.log(`[Tunnel] Downloading cloudflared from ${url}...`);
+    await downloadFile(url, tempFile);
+    console.log("[Tunnel] Extracting cloudflared...");
+    await extractTgz(tempFile, binDir);
+    fs5.unlinkSync(tempFile);
+  } else {
+    console.log(`[Tunnel] Downloading cloudflared from ${url}...`);
+    await downloadFile(url, cloudflaredPath);
+  }
+  if (os2.platform() !== "win32") {
+    fs5.chmodSync(cloudflaredPath, 493);
+  }
+  if (!verifyCloudflared(cloudflaredPath)) {
+    throw new Error("Downloaded cloudflared binary failed verification");
+  }
+  console.log("[Tunnel] cloudflared installed successfully");
+  return cloudflaredPath;
+}
+async function ensureCloudflared() {
+  const pathBinary = isCloudflaredInPath();
+  if (pathBinary && verifyCloudflared(pathBinary)) {
+    return pathBinary;
+  }
+  const episodaBinary = getCloudflaredPath();
+  if (isCloudflaredInstalled() && verifyCloudflared(episodaBinary)) {
+    return episodaBinary;
+  }
+  return downloadCloudflared();
+}
+
+// src/tunnel/tunnel-manager.ts
+var import_child_process6 = require("child_process");
+var import_events = require("events");
+var TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+var DEFAULT_RECONNECT_CONFIG = {
+  maxRetries: 5,
+  initialDelayMs: 1e3,
+  maxDelayMs: 3e4,
+  backoffMultiplier: 2
+};
+var TunnelManager = class extends import_events.EventEmitter {
+  constructor(config) {
+    super();
+    this.tunnelStates = /* @__PURE__ */ new Map();
+    this.cloudflaredPath = null;
+    this.reconnectConfig = { ...DEFAULT_RECONNECT_CONFIG, ...config };
+  }
+  /**
+   * Emit typed tunnel events
+   */
+  emitEvent(event) {
+    this.emit("tunnel", event);
+  }
+  /**
+   * Initialize the tunnel manager
+   * Ensures cloudflared is available
+   */
+  async initialize() {
+    this.cloudflaredPath = await ensureCloudflared();
+  }
+  /**
+   * EP672-9: Calculate delay for exponential backoff
+   */
+  calculateBackoffDelay(retryCount) {
+    const delay = this.reconnectConfig.initialDelayMs * Math.pow(this.reconnectConfig.backoffMultiplier, retryCount);
+    return Math.min(delay, this.reconnectConfig.maxDelayMs);
+  }
+  /**
+   * EP672-9: Attempt to reconnect a crashed tunnel
+   */
+  async attemptReconnect(moduleUid) {
+    const state = this.tunnelStates.get(moduleUid);
+    if (!state || state.intentionallyStopped) {
+      return;
+    }
+    if (state.retryCount >= this.reconnectConfig.maxRetries) {
+      console.log(`[Tunnel] Max retries (${this.reconnectConfig.maxRetries}) reached for ${moduleUid}, giving up`);
+      this.emitEvent({
+        type: "error",
+        moduleUid,
+        error: `Tunnel failed after ${this.reconnectConfig.maxRetries} reconnection attempts`
+      });
+      state.options.onStatusChange?.("error", "Max reconnection attempts reached");
+      this.tunnelStates.delete(moduleUid);
+      return;
+    }
+    const delay = this.calculateBackoffDelay(state.retryCount);
+    console.log(`[Tunnel] Reconnecting ${moduleUid} in ${delay}ms (attempt ${state.retryCount + 1}/${this.reconnectConfig.maxRetries})`);
+    this.emitEvent({ type: "reconnecting", moduleUid });
+    state.options.onStatusChange?.("reconnecting");
+    state.retryTimeoutId = setTimeout(async () => {
+      state.retryCount++;
+      const result = await this.startTunnelProcess(state.options, state);
+      if (result.success) {
+        console.log(`[Tunnel] Reconnected ${moduleUid} successfully with new URL: ${result.url}`);
+        state.retryCount = 0;
+      }
+    }, delay);
+  }
+  /**
+   * EP672-9: Internal method to start the tunnel process
+   * Separated from startTunnel to support reconnection
+   */
+  async startTunnelProcess(options, existingState) {
+    const { moduleUid, port = 3e3, onUrl, onStatusChange } = options;
+    if (!this.cloudflaredPath) {
+      try {
+        this.cloudflaredPath = await ensureCloudflared();
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { success: false, error: `Failed to get cloudflared: ${errorMessage}` };
+      }
+    }
+    return new Promise((resolve2) => {
+      const tunnelInfo = {
+        moduleUid,
+        url: "",
+        port,
+        status: "starting",
+        startedAt: /* @__PURE__ */ new Date(),
+        process: null
+        // Will be set below
+      };
+      const process2 = (0, import_child_process6.spawn)(this.cloudflaredPath, [
+        "tunnel",
+        "--url",
+        `http://localhost:${port}`
+      ], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      tunnelInfo.process = process2;
+      tunnelInfo.pid = process2.pid;
+      const state = existingState || {
+        info: tunnelInfo,
+        options,
+        intentionallyStopped: false,
+        retryCount: 0,
+        retryTimeoutId: null
+      };
+      state.info = tunnelInfo;
+      this.tunnelStates.set(moduleUid, state);
+      let urlFound = false;
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      const parseOutput = (data) => {
+        if (urlFound) return;
+        const match = data.match(TUNNEL_URL_REGEX);
+        if (match) {
+          urlFound = true;
+          tunnelInfo.url = match[0];
+          tunnelInfo.status = "connected";
+          onStatusChange?.("connected");
+          onUrl?.(tunnelInfo.url);
+          this.emitEvent({
+            type: "started",
+            moduleUid,
+            url: tunnelInfo.url
+          });
+          resolve2({ success: true, url: tunnelInfo.url });
+        }
+      };
+      process2.stdout?.on("data", (data) => {
+        stdoutBuffer += data.toString();
+        parseOutput(stdoutBuffer);
+      });
+      process2.stderr?.on("data", (data) => {
+        stderrBuffer += data.toString();
+        parseOutput(stderrBuffer);
+      });
+      process2.on("exit", (code, signal) => {
+        const wasConnected = tunnelInfo.status === "connected";
+        tunnelInfo.status = "disconnected";
+        const currentState = this.tunnelStates.get(moduleUid);
+        if (!urlFound) {
+          const errorMsg = `Tunnel process exited with code ${code}`;
+          tunnelInfo.status = "error";
+          tunnelInfo.error = errorMsg;
+          if (currentState && !currentState.intentionallyStopped) {
+            this.attemptReconnect(moduleUid);
+          } else {
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("error", errorMsg);
+            this.emitEvent({ type: "error", moduleUid, error: errorMsg });
+          }
+          resolve2({ success: false, error: errorMsg });
+        } else if (wasConnected) {
+          if (currentState && !currentState.intentionallyStopped) {
+            console.log(`[Tunnel] ${moduleUid} crashed unexpectedly, attempting reconnect...`);
+            onStatusChange?.("reconnecting");
+            this.attemptReconnect(moduleUid);
+          } else {
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("disconnected");
+            this.emitEvent({ type: "stopped", moduleUid });
+          }
+        }
+      });
+      process2.on("error", (error) => {
+        tunnelInfo.status = "error";
+        tunnelInfo.error = error.message;
+        const currentState = this.tunnelStates.get(moduleUid);
+        if (currentState && !currentState.intentionallyStopped) {
+          this.attemptReconnect(moduleUid);
+        } else {
+          this.tunnelStates.delete(moduleUid);
+          onStatusChange?.("error", error.message);
+          this.emitEvent({ type: "error", moduleUid, error: error.message });
+        }
+        if (!urlFound) {
+          resolve2({ success: false, error: error.message });
+        }
+      });
+      setTimeout(() => {
+        if (!urlFound) {
+          process2.kill();
+          const errorMsg = "Tunnel startup timed out after 30 seconds";
+          tunnelInfo.status = "error";
+          tunnelInfo.error = errorMsg;
+          const currentState = this.tunnelStates.get(moduleUid);
+          if (currentState && !currentState.intentionallyStopped) {
+            this.attemptReconnect(moduleUid);
+          } else {
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("error", errorMsg);
+            this.emitEvent({ type: "error", moduleUid, error: errorMsg });
+          }
+          resolve2({ success: false, error: errorMsg });
+        }
+      }, 3e4);
+    });
+  }
+  /**
+   * Start a tunnel for a module
+   */
+  async startTunnel(options) {
+    const { moduleUid } = options;
+    const existingState = this.tunnelStates.get(moduleUid);
+    if (existingState) {
+      if (existingState.info.status === "connected") {
+        return { success: true, url: existingState.info.url };
+      }
+      await this.stopTunnel(moduleUid);
+    }
+    return this.startTunnelProcess(options);
+  }
+  /**
+   * Stop a tunnel for a module
+   */
+  async stopTunnel(moduleUid) {
+    const state = this.tunnelStates.get(moduleUid);
+    if (!state) {
+      return;
+    }
+    state.intentionallyStopped = true;
+    if (state.retryTimeoutId) {
+      clearTimeout(state.retryTimeoutId);
+      state.retryTimeoutId = null;
+    }
+    const tunnel = state.info;
+    if (tunnel.process && !tunnel.process.killed) {
+      tunnel.process.kill("SIGTERM");
+      await new Promise((resolve2) => {
+        const timeout = setTimeout(() => {
+          if (tunnel.process && !tunnel.process.killed) {
+            tunnel.process.kill("SIGKILL");
+          }
+          resolve2();
+        }, 3e3);
+        tunnel.process.once("exit", () => {
+          clearTimeout(timeout);
+          resolve2();
+        });
+      });
+    }
+    this.tunnelStates.delete(moduleUid);
+    this.emitEvent({ type: "stopped", moduleUid });
+  }
+  /**
+   * Stop all active tunnels
+   */
+  async stopAllTunnels() {
+    const moduleUids = Array.from(this.tunnelStates.keys());
+    await Promise.all(moduleUids.map((uid) => this.stopTunnel(uid)));
+  }
+  /**
+   * Get information about an active tunnel
+   */
+  getTunnel(moduleUid) {
+    const state = this.tunnelStates.get(moduleUid);
+    if (!state) return null;
+    const { process: process2, ...info } = state.info;
+    return info;
+  }
+  /**
+   * Get all active tunnels
+   */
+  getAllTunnels() {
+    return Array.from(this.tunnelStates.values()).map((state) => {
+      const { process: process2, ...info } = state.info;
+      return info;
+    });
+  }
+  /**
+   * Check if a tunnel is active for a module
+   */
+  hasTunnel(moduleUid) {
+    return this.tunnelStates.has(moduleUid);
+  }
+  /**
+   * Get the URL for an active tunnel
+   */
+  getTunnelUrl(moduleUid) {
+    return this.tunnelStates.get(moduleUid)?.info.url || null;
+  }
+};
+var tunnelManagerInstance = null;
+function getTunnelManager() {
+  if (!tunnelManagerInstance) {
+    tunnelManagerInstance = new TunnelManager();
+  }
+  return tunnelManagerInstance;
+}
+
+// src/commands/tunnel.ts
+var https2 = __toESM(require("https"));
+async function checkTunnelHealth(url, timeoutMs = 5e3) {
+  return new Promise((resolve2) => {
+    try {
+      const urlObj = new URL(url);
+      const req = https2.request({
+        hostname: urlObj.hostname,
+        path: urlObj.pathname || "/",
+        method: "HEAD",
+        timeout: timeoutMs
+      }, (res) => {
+        resolve2({ reachable: true, statusCode: res.statusCode });
+      });
+      req.on("error", (err) => {
+        resolve2({ reachable: false, error: err.message });
+      });
+      req.on("timeout", () => {
+        req.destroy();
+        resolve2({ reachable: false, error: "Connection timed out" });
+      });
+      req.end();
+    } catch (err) {
+      resolve2({ reachable: false, error: err instanceof Error ? err.message : "Invalid URL" });
+    }
+  });
+}
+async function tunnelStartCommand(options = {}) {
+  try {
+    const config = await (0, import_core7.loadConfig)();
+    if (!config || !config.access_token || !config.project_id) {
+      status.error("Not authenticated. Please run: episoda auth");
+      process.exit(1);
+    }
+    const port = options.port || getServerPort();
+    const moduleUid = options.moduleUid || "LOCAL";
+    const serverRunning = await isPortInUse(port);
+    if (!serverRunning) {
+      status.warning(`No server detected on port ${port}`);
+      status.info("Start your dev server first, or specify a different port with --port");
+      process.exit(1);
+    }
+    status.info(`Starting tunnel for localhost:${port}...`);
+    const tunnelManager = getTunnelManager();
+    await tunnelManager.initialize();
+    const result = await tunnelManager.startTunnel({
+      moduleUid,
+      port,
+      onUrl: (url) => {
+        status.success(`Tunnel started: ${url}`);
+      },
+      onStatusChange: (newStatus, error) => {
+        if (newStatus === "error") {
+          status.error(`Tunnel error: ${error}`);
+        }
+      }
+    });
+    if (!result.success) {
+      status.error(`Failed to start tunnel: ${result.error}`);
+      process.exit(1);
+    }
+    if (result.url && moduleUid !== "LOCAL") {
+      try {
+        const apiUrl = config.api_url || "https://episoda.dev";
+        const response = await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${config.access_token}`,
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ tunnel_url: result.url })
+        });
+        if (response.ok) {
+          status.success(`Tunnel URL reported to Episoda for module ${moduleUid}`);
+        } else {
+          const data = await response.json().catch(() => ({}));
+          status.warning(`Could not report tunnel URL: ${data.message || response.statusText}`);
+        }
+      } catch (error) {
+        status.warning(`Could not report tunnel URL to platform: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    status.info("");
+    status.info("Tunnel is running. Press Ctrl+C to stop.");
+    status.info(`Preview URL: ${result.url}`);
+    status.info("");
+    await new Promise((resolve2) => {
+      const cleanup = async () => {
+        status.info("\nStopping tunnel...");
+        await tunnelManager.stopTunnel(moduleUid);
+        if (moduleUid !== "LOCAL") {
+          try {
+            const apiUrl = config.api_url || "https://episoda.dev";
+            await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+              method: "DELETE",
+              headers: {
+                "Authorization": `Bearer ${config.access_token}`
+              }
+            });
+          } catch {
+          }
+        }
+        status.success("Tunnel stopped");
+        resolve2();
+      };
+      process.on("SIGTERM", cleanup);
+      process.on("SIGINT", cleanup);
+    });
+  } catch (error) {
+    status.error(`Tunnel command failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+async function tunnelStopCommand(options = {}) {
+  try {
+    const config = await (0, import_core7.loadConfig)();
+    const moduleUid = options.moduleUid || "LOCAL";
+    const tunnelManager = getTunnelManager();
+    const tunnel = tunnelManager.getTunnel(moduleUid);
+    if (!tunnel) {
+      status.info("No active tunnel found");
+      return;
+    }
+    status.info(`Stopping tunnel for ${moduleUid}...`);
+    await tunnelManager.stopTunnel(moduleUid);
+    if (config?.access_token && moduleUid !== "LOCAL") {
+      try {
+        const apiUrl = config.api_url || "https://episoda.dev";
+        await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+          method: "DELETE",
+          headers: {
+            "Authorization": `Bearer ${config.access_token}`
+          }
+        });
+      } catch {
+      }
+    }
+    status.success("Tunnel stopped");
+  } catch (error) {
+    status.error(`Failed to stop tunnel: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+async function tunnelStatusCommand() {
+  try {
+    const tunnelManager = getTunnelManager();
+    const tunnels = tunnelManager.getAllTunnels();
+    if (tunnels.length === 0) {
+      status.info("No active tunnels");
+      return;
+    }
+    status.info("Active tunnels:");
+    for (const tunnel of tunnels) {
+      status.info("");
+      status.info(`  Module: ${tunnel.moduleUid}`);
+      status.info(`  URL: ${tunnel.url}`);
+      status.info(`  Port: ${tunnel.port}`);
+      status.info(`  Status: ${tunnel.status}`);
+      status.info(`  Started: ${tunnel.startedAt.toLocaleString()}`);
+      if (tunnel.url && tunnel.status === "connected") {
+        status.info("  Health: Checking...");
+        const health = await checkTunnelHealth(tunnel.url);
+        if (health.reachable) {
+          status.success(`  Health: \u2713 Online (HTTP ${health.statusCode})`);
+        } else {
+          status.warning(`  Health: \u2717 Unreachable (${health.error})`);
+        }
+      }
+    }
+  } catch (error) {
+    status.error(`Failed to get tunnel status: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+}
+
 // src/index.ts
-import_commander.program.name("episoda").description("Episoda local development workflow orchestration").version(import_core7.VERSION);
+import_commander.program.name("episoda").description("Episoda local development workflow orchestration").version(import_core8.VERSION);
 import_commander.program.command("auth").description("Authenticate to Episoda via OAuth and configure CLI").option("--api-url <url>", "API URL (default: https://episoda.dev)").action(async (options) => {
   try {
     await authCommand(options);
@@ -3866,5 +4492,35 @@ import_commander.program.command("disconnect").description("Disconnect from epis
     process.exit(1);
   }
 });
+var tunnelCmd = import_commander.program.command("tunnel").description("Manage Cloudflare tunnels for local dev preview");
+tunnelCmd.command("start").description("Start a tunnel to expose local dev server").option("-p, --port <port>", "Local port to tunnel (default: 3000)", (val) => parseInt(val, 10)).option("-m, --module <uid>", "Module UID to associate with tunnel").action(async (options) => {
+  try {
+    await tunnelStartCommand({
+      port: options.port,
+      moduleUid: options.module
+    });
+  } catch (error) {
+    status.error(`Tunnel start failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+tunnelCmd.command("stop").description("Stop a running tunnel").option("-m, --module <uid>", "Module UID of tunnel to stop").action(async (options) => {
+  try {
+    await tunnelStopCommand({
+      moduleUid: options.module
+    });
+  } catch (error) {
+    status.error(`Tunnel stop failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
+tunnelCmd.command("status").description("Show active tunnels").action(async () => {
+  try {
+    await tunnelStatusCommand();
+  } catch (error) {
+    status.error(`Tunnel status failed: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+});
 import_commander.program.parse();
 //# sourceMappingURL=index.js.map