episoda 0.2.16 → 0.2.17

package/dist/daemon/daemon-process.js

@@ -2280,7 +2280,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.15",
+      version: "0.2.16",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3792,7 +3792,7 @@ 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;
@@ -3812,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
    */
@@ -3830,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();
@@ -4276,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);
@@ -4469,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
    */
@@ -4476,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);