episoda 0.2.14 → 0.2.16

package/dist/daemon/daemon-process.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 fs6 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs8 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs6.access(rebaseMergePath);
+              await fs8.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs6.access(rebaseApplyPath);
+                await fs8.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1718,6 +1718,18 @@ var require_websocket_client = __commonJS({
         this.isIntentionalDisconnect = false;
         this.lastConnectAttemptTime = Date.now();
         this.lastErrorCode = void 0;
+        if (this.ws) {
+          try {
+            this.ws.removeAllListeners();
+            this.ws.terminate();
+          } catch {
+          }
+          this.ws = void 0;
+        }
+        if (this.reconnectTimeout) {
+          clearTimeout(this.reconnectTimeout);
+          this.reconnectTimeout = void 0;
+        }
         return new Promise((resolve2, reject) => {
           const connectionTimeout = setTimeout(() => {
             if (this.ws) {
@@ -1946,6 +1958,10 @@ var require_websocket_client = __commonJS({
           console.log("[EpisodaClient] Intentional disconnect - not reconnecting");
           return;
         }
+        if (this.reconnectTimeout) {
+          console.log("[EpisodaClient] Reconnection already scheduled, skipping duplicate");
+          return;
+        }
         if (this.heartbeatTimer) {
           clearInterval(this.heartbeatTimer);
           this.heartbeatTimer = void 0;
@@ -2102,31 +2118,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig2;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs6 = __importStar(require("fs"));
-    var path7 = __importStar(require("path"));
-    var os2 = __importStar(require("os"));
+    var fs8 = __importStar(require("fs"));
+    var path9 = __importStar(require("path"));
+    var os3 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir5() {
-      return process.env.EPISODA_CONFIG_DIR || path7.join(os2.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path9.join(os3.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path7.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
+      return path9.join(getConfigDir5(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path7.dirname(configPath);
-      const isNew = !fs6.existsSync(dir);
+      const dir = path9.dirname(configPath);
+      const isNew = !fs8.existsSync(dir);
       if (isNew) {
-        fs6.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs8.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path7.join(dir, ".nosync");
-        if (isNew || !fs6.existsSync(nosyncPath)) {
+        const nosyncPath = path9.join(dir, ".nosync");
+        if (isNew || !fs8.existsSync(nosyncPath)) {
           try {
-            fs6.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs8.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2138,11 +2154,11 @@ var require_auth = __commonJS({
     }
     async function loadConfig2(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (!fs6.existsSync(fullPath)) {
+      if (!fs8.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs6.readFileSync(fullPath, "utf8");
+        const content = fs8.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2155,7 +2171,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs6.writeFileSync(fullPath, content, { mode: 384 });
+        fs8.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2264,7 +2280,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.13",
+      version: "0.2.15",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -2291,6 +2307,7 @@ var require_package = __commonJS({
         commander: "^11.1.0",
         ora: "^5.4.1",
         semver: "7.7.3",
+        tar: "7.5.2",
         ws: "^8.18.0",
         zod: "^4.0.10"
       },
@@ -2298,6 +2315,7 @@ var require_package = __commonJS({
         "@episoda/core": "*",
         "@types/node": "^20.11.24",
         "@types/semver": "7.7.1",
+        "@types/tar": "6.1.13",
         "@types/ws": "^8.5.10",
         tsup: "8.5.1",
         typescript: "^5.3.3"
@@ -3136,10 +3154,643 @@ async function handleExec(command, projectPath) {
   });
 }
 
-// src/daemon/daemon-process.ts
+// src/tunnel/cloudflared-manager.ts
+var import_child_process4 = require("child_process");
 var fs5 = __toESM(require("fs"));
-var os = __toESM(require("os"));
 var path6 = __toESM(require("path"));
+var os = __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 path6.join(os.homedir(), ".episoda", "bin");
+}
+function getCloudflaredPath() {
+  const binaryName = os.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+  return path6.join(getEpisodaBinDir(), binaryName);
+}
+function isCloudflaredInPath() {
+  try {
+    const command = os.platform() === "win32" ? "where" : "which";
+    const binaryName = os.platform() === "win32" ? "cloudflared.exe" : "cloudflared";
+    const result = (0, import_child_process4.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_process4.spawnSync)(binaryPath, ["version"], { encoding: "utf-8", timeout: 5e3 });
+    return result.status === 0 && result.stdout.includes("cloudflared");
+  } catch {
+    return false;
+  }
+}
+function getDownloadUrl() {
+  const platform3 = os.platform();
+  const arch3 = os.arch();
+  const platformUrls = DOWNLOAD_URLS[platform3];
+  if (!platformUrls) {
+    return null;
+  }
+  return platformUrls[arch3] || 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: ${os.platform()} ${os.arch()}`);
+  }
+  const binDir = getEpisodaBinDir();
+  const cloudflaredPath = getCloudflaredPath();
+  fs5.mkdirSync(binDir, { recursive: true });
+  const isTgz = url.endsWith(".tgz");
+  if (isTgz) {
+    const tempFile = path6.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 (os.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_process5 = 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_process5.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/utils/dev-server.ts
+var import_child_process6 = require("child_process");
+
+// src/utils/port-check.ts
+var net2 = __toESM(require("net"));
+async function isPortInUse(port) {
+  return new Promise((resolve2) => {
+    const server = net2.createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        resolve2(true);
+      } else {
+        resolve2(false);
+      }
+    });
+    server.once("listening", () => {
+      server.close();
+      resolve2(false);
+    });
+    server.listen(port);
+  });
+}
+
+// src/utils/dev-server.ts
+var activeServers = /* @__PURE__ */ new Map();
+async function waitForPort(port, timeoutMs = 3e4) {
+  const startTime = Date.now();
+  const checkInterval = 500;
+  while (Date.now() - startTime < timeoutMs) {
+    if (await isPortInUse(port)) {
+      return true;
+    }
+    await new Promise((resolve2) => setTimeout(resolve2, checkInterval));
+  }
+  return false;
+}
+async function startDevServer(projectPath, port = 3e3, moduleUid = "default") {
+  if (await isPortInUse(port)) {
+    console.log(`[DevServer] Server already running on port ${port}`);
+    return { success: true, alreadyRunning: true };
+  }
+  if (activeServers.has(moduleUid)) {
+    const existing = activeServers.get(moduleUid);
+    if (existing && !existing.killed) {
+      console.log(`[DevServer] Process already exists for ${moduleUid}`);
+      return { success: true, alreadyRunning: true };
+    }
+  }
+  console.log(`[DevServer] Starting dev server for ${moduleUid} on port ${port}...`);
+  try {
+    const devProcess = (0, import_child_process6.spawn)("npm", ["run", "dev"], {
+      cwd: projectPath,
+      env: {
+        ...process.env,
+        PORT: String(port)
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    });
+    activeServers.set(moduleUid, devProcess);
+    devProcess.stdout?.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) {
+        console.log(`[DevServer:${moduleUid}] ${line}`);
+      }
+    });
+    devProcess.stderr?.on("data", (data) => {
+      const line = data.toString().trim();
+      if (line) {
+        console.error(`[DevServer:${moduleUid}] ${line}`);
+      }
+    });
+    devProcess.on("exit", (code, signal) => {
+      console.log(`[DevServer] Process for ${moduleUid} exited with code ${code}, signal ${signal}`);
+      activeServers.delete(moduleUid);
+    });
+    devProcess.on("error", (error) => {
+      console.error(`[DevServer] Process error for ${moduleUid}:`, error);
+      activeServers.delete(moduleUid);
+    });
+    console.log(`[DevServer] Waiting for server to start on port ${port}...`);
+    const serverReady = await waitForPort(port, 6e4);
+    if (!serverReady) {
+      devProcess.kill();
+      activeServers.delete(moduleUid);
+      return { success: false, error: "Dev server failed to start within timeout" };
+    }
+    console.log(`[DevServer] Server started successfully on port ${port}`);
+    return { success: true };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.error(`[DevServer] Failed to start:`, error);
+    return { success: false, error: errorMsg };
+  }
+}
+async function stopDevServer(moduleUid) {
+  const process2 = activeServers.get(moduleUid);
+  if (process2 && !process2.killed) {
+    console.log(`[DevServer] Stopping server for ${moduleUid}`);
+    process2.kill("SIGTERM");
+    await new Promise((resolve2) => setTimeout(resolve2, 2e3));
+    if (!process2.killed) {
+      process2.kill("SIGKILL");
+    }
+    activeServers.delete(moduleUid);
+  }
+}
+async function ensureDevServer(projectPath, port = 3e3, moduleUid = "default") {
+  if (await isPortInUse(port)) {
+    return { success: true };
+  }
+  return startDevServer(projectPath, port, moduleUid);
+}
+
+// src/utils/port-detect.ts
+var fs6 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var DEFAULT_PORT = 3e3;
+function detectDevPort(projectPath) {
+  const envPort = getPortFromEnv(projectPath);
+  if (envPort) {
+    console.log(`[PortDetect] Found PORT=${envPort} in .env`);
+    return envPort;
+  }
+  const scriptPort = getPortFromPackageJson(projectPath);
+  if (scriptPort) {
+    console.log(`[PortDetect] Found port ${scriptPort} in package.json dev script`);
+    return scriptPort;
+  }
+  console.log(`[PortDetect] Using default port ${DEFAULT_PORT}`);
+  return DEFAULT_PORT;
+}
+function getPortFromEnv(projectPath) {
+  const envPaths = [
+    path7.join(projectPath, ".env"),
+    path7.join(projectPath, ".env.local"),
+    path7.join(projectPath, ".env.development"),
+    path7.join(projectPath, ".env.development.local")
+  ];
+  for (const envPath of envPaths) {
+    try {
+      if (!fs6.existsSync(envPath)) continue;
+      const content = fs6.readFileSync(envPath, "utf-8");
+      const lines = content.split("\n");
+      for (const line of lines) {
+        const match = line.match(/^\s*PORT\s*=\s*["']?(\d+)["']?\s*(?:#.*)?$/);
+        if (match) {
+          const port = parseInt(match[1], 10);
+          if (port > 0 && port < 65536) {
+            return port;
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getPortFromPackageJson(projectPath) {
+  const packageJsonPath = path7.join(projectPath, "package.json");
+  try {
+    if (!fs6.existsSync(packageJsonPath)) return null;
+    const content = fs6.readFileSync(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    const devScript = pkg.scripts?.dev;
+    if (!devScript) return null;
+    const portMatch = devScript.match(/(?:--port[=\s]|-p[=\s])(\d+)/);
+    if (portMatch) {
+      const port = parseInt(portMatch[1], 10);
+      if (port > 0 && port < 65536) {
+        return port;
+      }
+    }
+    const envMatch = devScript.match(/PORT[=\s](\d+)/);
+    if (envMatch) {
+      const port = parseInt(envMatch[1], 10);
+      if (port > 0 && port < 65536) {
+        return port;
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+
+// src/daemon/daemon-process.ts
+var fs7 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path8 = __toESM(require("path"));
 var packageJson = require_package();
 var Daemon = class {
   constructor() {
@@ -3156,6 +3807,10 @@ var Daemon = class {
     // Updated by 'auth_success' (add) and 'disconnected' (remove) events
     this.liveConnections = /* @__PURE__ */ new Set();
     // projectPath
+    // EP813: Track connections that are still authenticating (in progress)
+    // Prevents race condition between restoreConnections() and add-project IPC
+    this.pendingConnections = /* @__PURE__ */ new Set();
+    // projectPath
     this.shuttingDown = false;
     this.ipcServer = new IPCServer();
   }
@@ -3215,27 +3870,40 @@ var Daemon = class {
         machineId: this.machineId,
         deviceId: this.deviceId,
         // EP726: UUID for unified device identification
-        hostname: os.hostname(),
-        platform: os.platform(),
-        arch: os.arch(),
+        hostname: os2.hostname(),
+        platform: os2.platform(),
+        arch: os2.arch(),
         projects
       };
     });
     this.ipcServer.on("add-project", async (params) => {
       const { projectId, projectPath } = params;
       addProject(projectId, projectPath);
-      try {
-        await this.connectProject(projectId, projectPath);
-        const isHealthy = this.isConnectionHealthy(projectPath);
-        if (!isHealthy) {
-          console.warn(`[Daemon] Connection completed but not healthy for ${projectPath}`);
-          return { success: false, connected: false, error: "Connection established but not healthy" };
+      const MAX_RETRIES = 3;
+      const INITIAL_DELAY = 1e3;
+      let lastError = "";
+      for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          await this.connectProject(projectId, projectPath);
+          const isHealthy = this.isConnectionHealthy(projectPath);
+          if (!isHealthy) {
+            console.warn(`[Daemon] Connection completed but not healthy for ${projectPath}`);
+            lastError = "Connection established but not healthy";
+            return { success: false, connected: false, error: lastError };
+          }
+          return { success: true, connected: true };
+        } catch (error) {
+          lastError = error instanceof Error ? error.message : String(error);
+          console.error(`[Daemon] Connection attempt ${attempt}/${MAX_RETRIES} failed:`, lastError);
+          if (attempt < MAX_RETRIES) {
+            const delay = INITIAL_DELAY * Math.pow(2, attempt - 1);
+            console.log(`[Daemon] Retrying in ${delay / 1e3}s...`);
+            await new Promise((resolve2) => setTimeout(resolve2, delay));
+            await this.disconnectProject(projectPath);
+          }
         }
-        return { success: true, connected: true };
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return { success: false, connected: false, error: errorMessage };
       }
+      return { success: false, connected: false, error: `Failed after ${MAX_RETRIES} attempts: ${lastError}` };
     });
     this.ipcServer.on("remove-project", async (params) => {
       const { projectPath } = params;
@@ -3310,6 +3978,19 @@ var Daemon = class {
         console.log(`[Daemon] Already connected to ${projectPath}`);
         return;
       }
+      if (this.pendingConnections.has(projectPath)) {
+        console.log(`[Daemon] Connection in progress for ${projectPath}, waiting...`);
+        const maxWait = 35e3;
+        const startTime = Date.now();
+        while (this.pendingConnections.has(projectPath) && Date.now() - startTime < maxWait) {
+          await new Promise((resolve2) => setTimeout(resolve2, 500));
+        }
+        if (this.liveConnections.has(projectPath)) {
+          console.log(`[Daemon] Pending connection succeeded for ${projectPath}`);
+          return;
+        }
+        console.warn(`[Daemon] Pending connection timed out for ${projectPath}`);
+      }
       console.warn(`[Daemon] Stale connection detected for ${projectPath}, forcing reconnection`);
       await this.disconnectProject(projectPath);
     }
@@ -3336,6 +4017,7 @@ var Daemon = class {
       gitExecutor
     };
     this.connections.set(projectPath, connection);
+    this.pendingConnections.add(projectPath);
     client.on("command", async (message) => {
       if (message.type === "command" && message.command) {
         console.log(`[Daemon] Received command for ${projectId}:`, message.command);
@@ -3415,6 +4097,150 @@ var Daemon = class {
         }
       }
     });
+    client.on("tunnel_command", async (message) => {
+      if (message.type === "tunnel_command" && message.command) {
+        const cmd = message.command;
+        console.log(`[Daemon] Received tunnel command for ${projectId}:`, cmd.action);
+        client.updateActivity();
+        try {
+          const tunnelManager = getTunnelManager();
+          let result;
+          if (cmd.action === "start") {
+            const port = cmd.port || detectDevPort(projectPath);
+            const previewUrl = `https://${cmd.moduleUid.toLowerCase()}-${cmd.projectUid.toLowerCase()}.episoda.site`;
+            const reportTunnelStatus = async (data) => {
+              const config2 = await (0, import_core5.loadConfig)();
+              if (config2?.access_token) {
+                try {
+                  const apiUrl = config2.api_url || "https://episoda.dev";
+                  const response = await fetch(`${apiUrl}/api/modules/${cmd.moduleUid}/tunnel`, {
+                    method: "POST",
+                    headers: {
+                      "Authorization": `Bearer ${config2.access_token}`,
+                      "Content-Type": "application/json"
+                    },
+                    body: JSON.stringify(data)
+                  });
+                  if (response.ok) {
+                    console.log(`[Daemon] Tunnel status reported for ${cmd.moduleUid}`);
+                  } else {
+                    console.warn(`[Daemon] Failed to report tunnel status: ${response.statusText}`);
+                  }
+                } catch (reportError) {
+                  console.warn(`[Daemon] Error reporting tunnel status:`, reportError);
+                }
+              }
+            };
+            (async () => {
+              const MAX_RETRIES = 3;
+              const RETRY_DELAY_MS = 2e3;
+              await reportTunnelStatus({
+                tunnel_started_at: (/* @__PURE__ */ new Date()).toISOString(),
+                tunnel_error: null
+                // Clear any previous error
+              });
+              try {
+                await tunnelManager.initialize();
+                console.log(`[Daemon] Ensuring dev server is running on port ${port}...`);
+                const devServerResult = await ensureDevServer(projectPath, port, cmd.moduleUid);
+                if (!devServerResult.success) {
+                  const errorMsg2 = `Dev server failed to start: ${devServerResult.error}`;
+                  console.error(`[Daemon] ${errorMsg2}`);
+                  await reportTunnelStatus({ tunnel_error: errorMsg2 });
+                  return;
+                }
+                console.log(`[Daemon] Dev server ready on port ${port}`);
+                let lastError;
+                for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+                  console.log(`[Daemon] Starting tunnel (attempt ${attempt}/${MAX_RETRIES})...`);
+                  const startResult = await tunnelManager.startTunnel({
+                    moduleUid: cmd.moduleUid,
+                    port,
+                    onUrl: async (url) => {
+                      console.log(`[Daemon] Tunnel URL for ${cmd.moduleUid}: ${url}`);
+                      await reportTunnelStatus({
+                        tunnel_url: url,
+                        tunnel_error: null
+                        // Clear error on success
+                      });
+                    },
+                    onStatusChange: (status, error) => {
+                      if (status === "error") {
+                        console.error(`[Daemon] Tunnel error for ${cmd.moduleUid}: ${error}`);
+                        reportTunnelStatus({ tunnel_error: error || "Tunnel connection error" });
+                      } else if (status === "reconnecting") {
+                        console.log(`[Daemon] Tunnel reconnecting for ${cmd.moduleUid}...`);
+                      }
+                    }
+                  });
+                  if (startResult.success) {
+                    console.log(`[Daemon] Tunnel started successfully for ${cmd.moduleUid}`);
+                    return;
+                  }
+                  lastError = startResult.error;
+                  console.warn(`[Daemon] Tunnel start attempt ${attempt} failed: ${lastError}`);
+                  if (attempt < MAX_RETRIES) {
+                    console.log(`[Daemon] Retrying in ${RETRY_DELAY_MS}ms...`);
+                    await new Promise((resolve2) => setTimeout(resolve2, RETRY_DELAY_MS));
+                  }
+                }
+                const errorMsg = `Tunnel failed after ${MAX_RETRIES} attempts: ${lastError}`;
+                console.error(`[Daemon] ${errorMsg}`);
+                await reportTunnelStatus({ tunnel_error: errorMsg });
+              } catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`[Daemon] Async tunnel startup error:`, error);
+                await reportTunnelStatus({ tunnel_error: `Unexpected error: ${errorMsg}` });
+              }
+            })();
+            result = {
+              success: true,
+              previewUrl
+              // Note: actual tunnel URL will be reported via API when ready
+            };
+          } else if (cmd.action === "stop") {
+            await tunnelManager.stopTunnel(cmd.moduleUid);
+            await stopDevServer(cmd.moduleUid);
+            const config2 = await (0, import_core5.loadConfig)();
+            if (config2?.access_token) {
+              try {
+                const apiUrl = config2.api_url || "https://episoda.dev";
+                await fetch(`${apiUrl}/api/modules/${cmd.moduleUid}/tunnel`, {
+                  method: "DELETE",
+                  headers: {
+                    "Authorization": `Bearer ${config2.access_token}`
+                  }
+                });
+                console.log(`[Daemon] Tunnel URL cleared for ${cmd.moduleUid}`);
+              } catch {
+              }
+            }
+            result = { success: true };
+          } else {
+            result = {
+              success: false,
+              error: `Unknown tunnel action: ${cmd.action}`
+            };
+          }
+          await client.send({
+            type: "tunnel_result",
+            commandId: message.id,
+            result
+          });
+          console.log(`[Daemon] Tunnel command ${cmd.action} completed for ${cmd.moduleUid}:`, result.success ? "success" : "failed");
+        } catch (error) {
+          await client.send({
+            type: "tunnel_result",
+            commandId: message.id,
+            result: {
+              success: false,
+              error: error instanceof Error ? error.message : String(error)
+            }
+          });
+          console.error(`[Daemon] Tunnel command execution error:`, error);
+        }
+      }
+    });
     client.on("shutdown", async (message) => {
       const shutdownMessage = message;
       const reason = shutdownMessage.reason || "unknown";
@@ -3431,6 +4257,7 @@ var Daemon = class {
       console.log(`[Daemon] Authenticated for project ${projectId}`);
       touchProject(projectPath);
       this.liveConnections.add(projectPath);
+      this.pendingConnections.delete(projectPath);
       const authMessage = message;
       if (authMessage.userId && authMessage.workspaceId) {
         await this.configureGitUser(projectPath, authMessage.userId, authMessage.workspaceId, this.machineId, projectId, authMessage.deviceId);
@@ -3466,17 +4293,17 @@ var Daemon = class {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs5.existsSync(pidPath)) {
-          const pidStr = fs5.readFileSync(pidPath, "utf-8").trim();
+        if (fs7.existsSync(pidPath)) {
+          const pidStr = fs7.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
         console.warn(`[Daemon] Could not read daemon PID:`, pidError instanceof Error ? pidError.message : pidError);
       }
       const authSuccessPromise = new Promise((resolve2, reject) => {
-        const AUTH_TIMEOUT = 1e4;
+        const AUTH_TIMEOUT = 3e4;
         const timeout = setTimeout(() => {
-          reject(new Error("Authentication timeout - server did not respond with auth_success"));
+          reject(new Error("Authentication timeout after 30s - server may be under heavy load. Try again in a few seconds."));
         }, AUTH_TIMEOUT);
         const authHandler = () => {
           clearTimeout(timeout);
@@ -3491,9 +4318,9 @@ var Daemon = class {
         client.once("auth_error", errorHandler);
       });
       await client.connect(wsUrl, config.access_token, this.machineId, {
-        hostname: os.hostname(),
-        osPlatform: os.platform(),
-        osArch: os.arch(),
+        hostname: os2.hostname(),
+        osPlatform: os2.platform(),
+        osArch: os2.arch(),
         daemonPid
       });
       console.log(`[Daemon] Successfully connected to project ${projectId}`);
@@ -3502,6 +4329,7 @@ var Daemon = class {
     } catch (error) {
       console.error(`[Daemon] Failed to connect to ${projectId}:`, error);
       this.connections.delete(projectPath);
+      this.pendingConnections.delete(projectPath);
       throw error;
     }
   }
@@ -3519,6 +4347,7 @@ var Daemon = class {
     await connection.client.disconnect();
     this.connections.delete(projectPath);
     this.liveConnections.delete(projectPath);
+    this.pendingConnections.delete(projectPath);
     console.log(`[Daemon] Disconnected from ${projectPath}`);
   }
   /**
@@ -3544,29 +4373,29 @@ var Daemon = class {
    */
   async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, deviceId) {
     try {
-      const { execSync: execSync2 } = await import("child_process");
-      execSync2(`git config episoda.userId ${userId}`, {
+      const { execSync: execSync3 } = await import("child_process");
+      execSync3(`git config episoda.userId ${userId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync2(`git config episoda.workspaceId ${workspaceId}`, {
+      execSync3(`git config episoda.workspaceId ${workspaceId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync2(`git config episoda.machineId ${machineId}`, {
+      execSync3(`git config episoda.machineId ${machineId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
-      execSync2(`git config episoda.projectId ${projectId}`, {
+      execSync3(`git config episoda.projectId ${projectId}`, {
         cwd: projectPath,
         encoding: "utf8",
         stdio: "pipe"
       });
       if (deviceId) {
-        execSync2(`git config episoda.deviceId ${deviceId}`, {
+        execSync3(`git config episoda.deviceId ${deviceId}`, {
           cwd: projectPath,
           encoding: "utf8",
           stdio: "pipe"
@@ -3586,27 +4415,27 @@ var Daemon = class {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit"];
-    const hooksDir = path6.join(projectPath, ".git", "hooks");
-    if (!fs5.existsSync(hooksDir)) {
+    const hooksDir = path8.join(projectPath, ".git", "hooks");
+    if (!fs7.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path6.join(hooksDir, hookName);
-        const bundledHookPath = path6.join(__dirname, "..", "hooks", hookName);
-        if (!fs5.existsSync(bundledHookPath)) {
+        const hookPath = path8.join(hooksDir, hookName);
+        const bundledHookPath = path8.join(__dirname, "..", "hooks", hookName);
+        if (!fs7.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs5.readFileSync(bundledHookPath, "utf-8");
-        if (fs5.existsSync(hookPath)) {
-          const existingContent = fs5.readFileSync(hookPath, "utf-8");
+        const hookContent = fs7.readFileSync(bundledHookPath, "utf-8");
+        if (fs7.existsSync(hookPath)) {
+          const existingContent = fs7.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs5.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs7.writeFileSync(hookPath, hookContent, { mode: 493 });
         console.log(`[Daemon] Installed git hook: ${hookName}`);
       } catch (error) {
         console.warn(`[Daemon] Failed to install ${hookName} hook:`, error instanceof Error ? error.message : error);
@@ -3654,6 +4483,13 @@ var Daemon = class {
       await connection.client.disconnect();
     }
     this.connections.clear();
+    try {
+      const tunnelManager = getTunnelManager();
+      await tunnelManager.stopAllTunnels();
+      console.log("[Daemon] All tunnels stopped");
+    } catch (error) {
+      console.error("[Daemon] Failed to stop tunnels:", error);
+    }
     await this.ipcServer.stop();
     console.log("[Daemon] Shutdown complete");
   }
@@ -3665,8 +4501,8 @@ var Daemon = class {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs5.existsSync(pidPath)) {
-        fs5.unlinkSync(pidPath);
+      if (fs7.existsSync(pidPath)) {
+        fs7.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {