episoda 0.2.15 → 0.2.17

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;
@@ -2118,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
@@ -2154,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) {
@@ -2171,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)}`);
       }
@@ -2280,7 +2280,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.14",
+      version: "0.2.16",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -2307,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"
       },
@@ -2314,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"
@@ -3152,12 +3154,645 @@ 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 {
+var Daemon = class _Daemon {
   constructor() {
     this.machineId = "";
     this.deviceId = null;
@@ -3177,8 +3812,16 @@ var Daemon = class {
     this.pendingConnections = /* @__PURE__ */ new Set();
     // projectPath
     this.shuttingDown = false;
+    // EP822: Periodic tunnel polling interval
+    this.tunnelPollInterval = null;
+    // 15 seconds
+    // EP822: Prevent concurrent tunnel syncs (backpressure guard)
+    this.tunnelSyncInProgress = false;
     this.ipcServer = new IPCServer();
   }
+  static {
+    this.TUNNEL_POLL_INTERVAL_MS = 15e3;
+  }
   /**
    * Start the daemon
    */
@@ -3195,6 +3838,8 @@ var Daemon = class {
     console.log("[Daemon] IPC server started");
     this.registerIPCHandlers();
     await this.restoreConnections();
+    await this.cleanupOrphanedTunnels();
+    this.startTunnelPolling();
     this.setupShutdownHandlers();
     console.log("[Daemon] Daemon started successfully");
     this.checkAndNotifyUpdates();
@@ -3235,9 +3880,9 @@ 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
       };
     });
@@ -3462,6 +4107,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";
@@ -3497,6 +4286,9 @@ var Daemon = class {
         this.flyMachineId = authMessage.flyMachineId;
         console.log(`[Daemon] Fly Machine ID: ${this.flyMachineId}`);
       }
+      this.autoStartTunnelsForProject(projectPath, projectId).catch((error) => {
+        console.error(`[Daemon] EP819: Failed to auto-start tunnels:`, error);
+      });
     });
     client.on("error", (message) => {
       console.error(`[Daemon] Server error for ${projectId}:`, message);
@@ -3514,8 +4306,8 @@ 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) {
@@ -3539,9 +4331,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}`);
@@ -3594,29 +4386,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"
@@ -3636,27 +4428,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);
@@ -3690,6 +4482,295 @@ var Daemon = class {
       console.warn("[Daemon] Failed to cache device ID:", error instanceof Error ? error.message : error);
     }
   }
+  /**
+   * EP819: Auto-start tunnels for active local modules on daemon connect/reconnect
+   *
+   * Queries for modules in doing/review state with dev_mode=local that don't have
+   * an active tunnel_url, and starts tunnels for each.
+   */
+  async autoStartTunnelsForProject(projectPath, projectUid) {
+    console.log(`[Daemon] EP819: Checking for active local modules to auto-start tunnels...`);
+    try {
+      const config = await (0, import_core5.loadConfig)();
+      if (!config?.access_token) {
+        console.warn(`[Daemon] EP819: No access token, skipping tunnel auto-start`);
+        return;
+      }
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const response = await fetch(
+        `${apiUrl}/api/modules?state=doing,review&fields=id,uid,dev_mode,tunnel_url,checkout_machine_id`,
+        {
+          headers: {
+            "Authorization": `Bearer ${config.access_token}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      if (!response.ok) {
+        console.warn(`[Daemon] EP819: Failed to fetch modules: ${response.status}`);
+        return;
+      }
+      const data = await response.json();
+      const modules = data.modules || [];
+      const tunnelManager = getTunnelManager();
+      await tunnelManager.initialize();
+      const localModulesNeedingTunnel = modules.filter(
+        (m) => m.dev_mode === "local" && (!m.checkout_machine_id || m.checkout_machine_id === this.deviceId) && !tunnelManager.hasTunnel(m.uid)
+      );
+      if (localModulesNeedingTunnel.length === 0) {
+        console.log(`[Daemon] EP819: No local modules need tunnel auto-start`);
+        return;
+      }
+      console.log(`[Daemon] EP819: Found ${localModulesNeedingTunnel.length} local modules needing tunnels`);
+      for (const module2 of localModulesNeedingTunnel) {
+        const moduleUid = module2.uid;
+        const port = detectDevPort(projectPath);
+        console.log(`[Daemon] EP819: Auto-starting tunnel for ${moduleUid} on port ${port}`);
+        const reportTunnelStatus = async (statusData) => {
+          try {
+            const statusResponse = await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+              method: "POST",
+              headers: {
+                "Authorization": `Bearer ${config.access_token}`,
+                "Content-Type": "application/json"
+              },
+              body: JSON.stringify(statusData)
+            });
+            if (statusResponse.ok) {
+              console.log(`[Daemon] EP819: Tunnel status reported for ${moduleUid}`);
+            } else {
+              console.warn(`[Daemon] EP819: Failed to report tunnel status: ${statusResponse.statusText}`);
+            }
+          } catch (reportError) {
+            console.warn(`[Daemon] EP819: 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
+          });
+          try {
+            console.log(`[Daemon] EP819: Ensuring dev server is running for ${moduleUid}...`);
+            const devServerResult = await ensureDevServer(projectPath, port, moduleUid);
+            if (!devServerResult.success) {
+              const errorMsg2 = `Dev server failed to start: ${devServerResult.error}`;
+              console.error(`[Daemon] EP819: ${errorMsg2}`);
+              await reportTunnelStatus({ tunnel_error: errorMsg2 });
+              return;
+            }
+            console.log(`[Daemon] EP819: Dev server ready on port ${port}`);
+            let lastError;
+            for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+              console.log(`[Daemon] EP819: Starting tunnel for ${moduleUid} (attempt ${attempt}/${MAX_RETRIES})...`);
+              const startResult = await tunnelManager.startTunnel({
+                moduleUid,
+                port,
+                onUrl: async (url) => {
+                  console.log(`[Daemon] EP819: Tunnel URL for ${moduleUid}: ${url}`);
+                  await reportTunnelStatus({
+                    tunnel_url: url,
+                    tunnel_error: null
+                  });
+                },
+                onStatusChange: (status, error) => {
+                  if (status === "error") {
+                    console.error(`[Daemon] EP819: Tunnel error for ${moduleUid}: ${error}`);
+                    reportTunnelStatus({ tunnel_error: error || "Tunnel connection error" });
+                  } else if (status === "reconnecting") {
+                    console.log(`[Daemon] EP819: Tunnel reconnecting for ${moduleUid}...`);
+                  }
+                }
+              });
+              if (startResult.success) {
+                console.log(`[Daemon] EP819: Tunnel started successfully for ${moduleUid}`);
+                return;
+              }
+              lastError = startResult.error;
+              console.warn(`[Daemon] EP819: Tunnel start attempt ${attempt} failed: ${lastError}`);
+              if (attempt < MAX_RETRIES) {
+                console.log(`[Daemon] EP819: 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] EP819: ${errorMsg}`);
+            await reportTunnelStatus({ tunnel_error: errorMsg });
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            console.error(`[Daemon] EP819: Async tunnel startup error:`, error);
+            await reportTunnelStatus({ tunnel_error: `Unexpected error: ${errorMsg}` });
+          }
+        })();
+      }
+    } catch (error) {
+      console.error(`[Daemon] EP819: Error auto-starting tunnels:`, error);
+    }
+  }
+  /**
+   * EP822: Start periodic tunnel polling
+   *
+   * Polls every 30 seconds to detect module state changes and manage tunnels:
+   * - Start tunnels for modules entering doing/review state
+   * - Stop tunnels for modules leaving doing/review state
+   */
+  startTunnelPolling() {
+    if (this.tunnelPollInterval) {
+      console.log("[Daemon] EP822: Tunnel polling already running");
+      return;
+    }
+    console.log(`[Daemon] EP822: Starting tunnel polling (every ${_Daemon.TUNNEL_POLL_INTERVAL_MS / 1e3}s)`);
+    this.tunnelPollInterval = setInterval(() => {
+      this.syncTunnelsWithActiveModules().catch((error) => {
+        console.error("[Daemon] EP822: Tunnel sync error:", error);
+      });
+    }, _Daemon.TUNNEL_POLL_INTERVAL_MS);
+  }
+  /**
+   * EP822: Stop periodic tunnel polling
+   */
+  stopTunnelPolling() {
+    if (this.tunnelPollInterval) {
+      clearInterval(this.tunnelPollInterval);
+      this.tunnelPollInterval = null;
+      console.log("[Daemon] EP822: Tunnel polling stopped");
+    }
+  }
+  /**
+   * EP822: Clean up orphaned tunnels from previous daemon runs
+   *
+   * When the daemon crashes or is killed, tunnels may continue running.
+   * This method stops any tunnels that are running but shouldn't be,
+   * ensuring a clean slate on startup.
+   */
+  async cleanupOrphanedTunnels() {
+    try {
+      const tunnelManager = getTunnelManager();
+      const runningTunnels = tunnelManager.getAllTunnels();
+      if (runningTunnels.length === 0) {
+        return;
+      }
+      console.log(`[Daemon] EP822: Found ${runningTunnels.length} orphaned tunnel(s) from previous run, cleaning up...`);
+      for (const tunnel of runningTunnels) {
+        try {
+          await tunnelManager.stopTunnel(tunnel.moduleUid);
+          await stopDevServer(tunnel.moduleUid);
+          console.log(`[Daemon] EP822: Cleaned up orphaned tunnel for ${tunnel.moduleUid}`);
+        } catch (error) {
+          console.error(`[Daemon] EP822: Failed to clean up tunnel for ${tunnel.moduleUid}:`, error);
+        }
+      }
+      console.log("[Daemon] EP822: Orphaned tunnel cleanup complete");
+    } catch (error) {
+      console.error("[Daemon] EP822: Failed to clean up orphaned tunnels:", error);
+    }
+  }
+  /**
+   * EP822: Sync tunnels with active modules
+   *
+   * Compares running tunnels against modules in doing/review state.
+   * - Starts tunnels for modules that need them
+   * - Stops tunnels for modules that left active zone
+   *
+   * Fixes from peer review:
+   * - Backpressure guard prevents concurrent syncs
+   * - Uses deviceId (UUID) instead of machineId (string) for machine comparison
+   * - Groups modules by project_id for correct multi-project routing
+   */
+  async syncTunnelsWithActiveModules() {
+    if (this.tunnelSyncInProgress) {
+      console.log("[Daemon] EP822: Sync already in progress, skipping");
+      return;
+    }
+    if (this.liveConnections.size === 0) {
+      return;
+    }
+    this.tunnelSyncInProgress = true;
+    try {
+      const config = await (0, import_core5.loadConfig)();
+      if (!config?.access_token) {
+        return;
+      }
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const tunnelManager = getTunnelManager();
+      const runningTunnels = tunnelManager.getAllTunnels();
+      const runningModuleUids = new Set(runningTunnels.map((t) => t.moduleUid));
+      const response = await fetch(
+        `${apiUrl}/api/modules?state=doing,review&fields=id,uid,dev_mode,tunnel_url,checkout_machine_id,project_id`,
+        {
+          headers: {
+            "Authorization": `Bearer ${config.access_token}`,
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      if (!response.ok) {
+        console.warn(`[Daemon] EP822: Failed to fetch modules: ${response.status}`);
+        return;
+      }
+      const data = await response.json();
+      const modules = data.modules || [];
+      const activeLocalModules = modules.filter(
+        (m) => m.dev_mode === "local" && (!m.checkout_machine_id || m.checkout_machine_id === this.deviceId)
+      );
+      const activeModuleUids = new Set(activeLocalModules.map((m) => m.uid));
+      const modulesNeedingTunnel = activeLocalModules.filter(
+        (m) => !runningModuleUids.has(m.uid)
+      );
+      const tunnelsToStop = runningTunnels.filter(
+        (t) => !activeModuleUids.has(t.moduleUid)
+      );
+      if (modulesNeedingTunnel.length > 0) {
+        console.log(`[Daemon] EP822: Starting tunnels for ${modulesNeedingTunnel.length} module(s)`);
+        const modulesByProject = /* @__PURE__ */ new Map();
+        for (const module2 of modulesNeedingTunnel) {
+          const projectId = module2.project_id;
+          if (!projectId) continue;
+          if (!modulesByProject.has(projectId)) {
+            modulesByProject.set(projectId, []);
+          }
+          modulesByProject.get(projectId).push(module2);
+        }
+        const trackedProjects = getAllProjects();
+        for (const [projectId, projectModules] of modulesByProject) {
+          const project = trackedProjects.find((p) => p.id === projectId);
+          if (project) {
+            console.log(`[Daemon] EP822: Starting ${projectModules.length} tunnel(s) for project ${projectId}`);
+            await this.autoStartTunnelsForProject(project.path, project.id);
+          } else {
+            console.warn(`[Daemon] EP822: Project ${projectId} not tracked locally, skipping ${projectModules.length} module(s)`);
+          }
+        }
+      }
+      if (tunnelsToStop.length > 0) {
+        console.log(`[Daemon] EP822: Stopping ${tunnelsToStop.length} orphaned tunnel(s)`);
+        for (const tunnel of tunnelsToStop) {
+          try {
+            await tunnelManager.stopTunnel(tunnel.moduleUid);
+            await stopDevServer(tunnel.moduleUid);
+            try {
+              await fetch(`${apiUrl}/api/modules/${tunnel.moduleUid}/tunnel`, {
+                method: "DELETE",
+                headers: {
+                  "Authorization": `Bearer ${config.access_token}`
+                }
+              });
+              console.log(`[Daemon] EP822: Tunnel stopped and cleared for ${tunnel.moduleUid}`);
+            } catch {
+            }
+          } catch (error) {
+            console.error(`[Daemon] EP822: Failed to stop tunnel for ${tunnel.moduleUid}:`, error);
+          }
+        }
+      }
+    } catch (error) {
+      console.error("[Daemon] EP822: Error syncing tunnels:", error);
+    } finally {
+      this.tunnelSyncInProgress = false;
+    }
+  }
   /**
    * Gracefully shutdown daemon
    */
@@ -3697,6 +4778,7 @@ var Daemon = class {
     if (this.shuttingDown) return;
     this.shuttingDown = true;
     console.log("[Daemon] Shutting down...");
+    this.stopTunnelPolling();
     for (const [projectPath, connection] of this.connections) {
       if (connection.reconnectTimer) {
         clearTimeout(connection.reconnectTimer);
@@ -3704,6 +4786,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");
   }
@@ -3715,8 +4804,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) {