episoda 0.2.39 → 0.2.41

package/dist/daemon/daemon-process.js

@@ -2726,7 +2726,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.39",
+      version: "0.2.41",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4018,7 +4018,134 @@ var import_events = require("events");
 var fs6 = __toESM(require("fs"));
 var path7 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
+
+// src/tunnel/tunnel-api.ts
+var import_core6 = __toESM(require_dist());
+async function provisionNamedTunnel(moduleId) {
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    const response = await fetch(`${apiUrl}/api/tunnels`, {
+      method: "POST",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ module_id: moduleId })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      return {
+        success: false,
+        error: data.error?.message || data.message || `HTTP ${response.status}`
+      };
+    }
+    return {
+      success: true,
+      tunnel: data.data?.tunnel,
+      message: data.data?.message
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to provision tunnel"
+    };
+  }
+}
+async function provisionNamedTunnelByUid(moduleUid) {
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return { success: false, error: "Not authenticated" };
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    const moduleResponse = await fetch(`${apiUrl}/api/modules/${moduleUid}`, {
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`
+      }
+    });
+    if (!moduleResponse.ok) {
+      return {
+        success: false,
+        error: `Failed to find module ${moduleUid}`
+      };
+    }
+    const moduleData = await moduleResponse.json();
+    const moduleId = moduleData.data?.id;
+    if (!moduleId) {
+      return {
+        success: false,
+        error: `Module ${moduleUid} has no ID`
+      };
+    }
+    return provisionNamedTunnel(moduleId);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Failed to provision tunnel"
+    };
+  }
+}
+async function updateTunnelStatus(moduleUid, status, error) {
+  if (!moduleUid || moduleUid === "LOCAL") {
+    return;
+  }
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return;
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+      method: "PATCH",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        tunnel_health_status: status,
+        tunnel_last_health_check: (/* @__PURE__ */ new Date()).toISOString(),
+        ...error && { tunnel_error: error }
+      })
+    });
+  } catch {
+  }
+}
+async function clearTunnelUrl(moduleUid) {
+  if (!moduleUid || moduleUid === "LOCAL") {
+    return;
+  }
+  const config = await (0, import_core6.loadConfig)();
+  if (!config?.access_token) {
+    return;
+  }
+  try {
+    const apiUrl = config.api_url || "https://episoda.dev";
+    await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+      method: "DELETE",
+      headers: {
+        "Authorization": `Bearer ${config.access_token}`
+      }
+    });
+  } catch {
+  }
+}
+
+// src/tunnel/tunnel-manager.ts
 var TUNNEL_PID_DIR = path7.join(os2.homedir(), ".episoda", "tunnels");
+var TUNNEL_TIMEOUTS = {
+  /** Time to wait for Named Tunnel connection (includes API token fetch + connect) */
+  NAMED_TUNNEL_CONNECT: 6e4,
+  /** Time to wait for Quick Tunnel connection (simpler, faster connection) */
+  QUICK_TUNNEL_CONNECT: 3e4,
+  /** Time to wait for cloudflared process to start before giving up */
+  PROCESS_START: 1e4,
+  /** Grace period after starting cloudflared before checking status */
+  STARTUP_GRACE: 2e3
+};
 var TUNNEL_URL_REGEX = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
 var DEFAULT_RECONNECT_CONFIG = {
   maxRetries: 5,
@@ -4075,6 +4202,7 @@ var TunnelManager = class extends import_events.EventEmitter {
   }
   /**
    * EP877: Read PID from file
+   * EP948: Enhanced with validation and stale file cleanup
    */
   readPidFile(moduleUid) {
     try {
@@ -4082,9 +4210,25 @@ var TunnelManager = class extends import_events.EventEmitter {
       if (!fs6.existsSync(pidPath)) {
         return null;
       }
-      const pid = parseInt(fs6.readFileSync(pidPath, "utf8").trim(), 10);
-      return isNaN(pid) ? null : pid;
+      const content = fs6.readFileSync(pidPath, "utf8").trim();
+      const pid = parseInt(content, 10);
+      if (isNaN(pid) || pid <= 0) {
+        console.warn(`[Tunnel] EP948: Invalid PID file content for ${moduleUid}: "${content}", removing stale file`);
+        this.removePidFile(moduleUid);
+        return null;
+      }
+      if (!this.isProcessRunning(pid)) {
+        console.log(`[Tunnel] EP948: PID ${pid} for ${moduleUid} is not running, removing stale file`);
+        this.removePidFile(moduleUid);
+        return null;
+      }
+      return pid;
     } catch (error) {
+      console.warn(`[Tunnel] EP948: Failed to read PID file for ${moduleUid}: ${error.message}`);
+      try {
+        this.removePidFile(moduleUid);
+      } catch {
+      }
       return null;
     }
   }
@@ -4288,10 +4432,190 @@ var TunnelManager = class extends import_events.EventEmitter {
     }, delay);
   }
   /**
-   * EP672-9: Internal method to start the tunnel process
-   * Separated from startTunnel to support reconnection
+   * EP948: Start a Named Tunnel using a pre-provisioned token
+   * Named Tunnels connect to a persistent tunnel created via Cloudflare API
+   */
+  async startNamedTunnelProcess(options, existingState) {
+    const { moduleUid, port = 3e3, onUrl, onStatusChange, tunnelToken, previewUrl } = options;
+    if (!tunnelToken) {
+      return { success: false, error: "Named tunnel requires a token" };
+    }
+    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((resolve3) => {
+      const tunnelInfo = {
+        moduleUid,
+        url: previewUrl || "",
+        // Named tunnels have a known URL
+        port,
+        status: "starting",
+        startedAt: /* @__PURE__ */ new Date(),
+        process: null
+      };
+      console.log(`[Tunnel] EP948: Starting Named Tunnel for ${moduleUid} with preview URL ${previewUrl}`);
+      const process2 = (0, import_child_process6.spawn)(this.cloudflaredPath, [
+        "tunnel",
+        "run",
+        "--token",
+        tunnelToken
+      ], {
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      tunnelInfo.process = process2;
+      tunnelInfo.pid = process2.pid;
+      if (process2.pid) {
+        this.writePidFile(moduleUid, process2.pid);
+      }
+      const state = existingState || {
+        info: tunnelInfo,
+        options,
+        intentionallyStopped: false,
+        retryCount: 0,
+        retryTimeoutId: null
+      };
+      state.info = tunnelInfo;
+      this.tunnelStates.set(moduleUid, state);
+      let connected = false;
+      let stderrBuffer = "";
+      const connectionPatterns = [
+        /Connection.*registered/i,
+        // "Connection [id] registered"
+        /Registered tunnel connection/i,
+        // Alternative format
+        /connected to.*connector/i,
+        // "connected to [colo] connector ID"
+        /Tunnel is ready/i,
+        // Some versions use this
+        /ingress.*rules.*applied/i,
+        // Indicates ingress rules are active
+        /Initial.*connection.*established/i
+        // Initial connection message
+      ];
+      const checkConnection = (data) => {
+        if (connected) return;
+        const isConnected = connectionPatterns.some((pattern) => pattern.test(data));
+        if (isConnected) {
+          connected = true;
+          tunnelInfo.status = "connected";
+          tunnelInfo.url = previewUrl || "";
+          console.log(`[Tunnel] EP948: Named Tunnel connected for ${moduleUid}: ${previewUrl}`);
+          updateTunnelStatus(moduleUid, "healthy").catch(() => {
+          });
+          onStatusChange?.("connected");
+          onUrl?.(tunnelInfo.url);
+          this.emitEvent({
+            type: "started",
+            moduleUid,
+            url: tunnelInfo.url
+          });
+          resolve3({ success: true, url: tunnelInfo.url });
+        }
+      };
+      process2.stderr?.on("data", (data) => {
+        stderrBuffer += data.toString();
+        checkConnection(stderrBuffer);
+      });
+      process2.stdout?.on("data", (data) => {
+        checkConnection(data.toString());
+      });
+      process2.on("exit", (code, signal) => {
+        const wasConnected = tunnelInfo.status === "connected";
+        tunnelInfo.status = "disconnected";
+        const currentState = this.tunnelStates.get(moduleUid);
+        if (!connected) {
+          const errorMsg = `Named tunnel process exited with code ${code}`;
+          tunnelInfo.status = "error";
+          tunnelInfo.error = errorMsg;
+          updateTunnelStatus(moduleUid, "error", errorMsg).catch(() => {
+          });
+          if (currentState && !currentState.intentionallyStopped) {
+            this.attemptReconnect(moduleUid);
+          } else {
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("error", errorMsg);
+            this.emitEvent({ type: "error", moduleUid, error: errorMsg });
+          }
+          resolve3({ success: false, error: errorMsg });
+        } else if (wasConnected) {
+          if (currentState && !currentState.intentionallyStopped) {
+            console.log(`[Tunnel] EP948: Named tunnel ${moduleUid} crashed unexpectedly, attempting reconnect...`);
+            updateTunnelStatus(moduleUid, "disconnected").catch(() => {
+            });
+            onStatusChange?.("reconnecting");
+            this.attemptReconnect(moduleUid);
+          } else {
+            updateTunnelStatus(moduleUid, "disconnected").catch(() => {
+            });
+            this.tunnelStates.delete(moduleUid);
+            onStatusChange?.("disconnected");
+            this.emitEvent({ type: "stopped", moduleUid });
+          }
+        }
+      });
+      process2.on("error", (error) => {
+        tunnelInfo.status = "error";
+        tunnelInfo.error = error.message;
+        updateTunnelStatus(moduleUid, "error", error.message).catch(() => {
+        });
+        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 (!connected) {
+          resolve3({ success: false, error: error.message });
+        }
+      });
+      setTimeout(() => {
+        if (!connected) {
+          process2.kill();
+          if (stderrBuffer) {
+            console.error(`[Tunnel] EP948: Named tunnel ${moduleUid} stderr before timeout:`);
+            console.error(stderrBuffer.slice(-2e3));
+          }
+          const errorMsg = "Named tunnel connection timed out after 60 seconds. Check logs for cloudflared output.";
+          tunnelInfo.status = "error";
+          tunnelInfo.error = errorMsg;
+          updateTunnelStatus(moduleUid, "error", errorMsg).catch(() => {
+          });
+          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 });
+          }
+          resolve3({ success: false, error: errorMsg });
+        }
+      }, TUNNEL_TIMEOUTS.NAMED_TUNNEL_CONNECT);
+    });
+  }
+  /**
+   * EP948: Route to the appropriate tunnel process method based on mode
    */
   async startTunnelProcess(options, existingState) {
+    const mode = options.mode || "named";
+    if (mode === "named" && options.tunnelToken) {
+      return this.startNamedTunnelProcess(options, existingState);
+    }
+    console.log(`[Tunnel] EP948: Using Quick Tunnel mode for ${options.moduleUid}`);
+    return this.startQuickTunnelProcess(options, existingState);
+  }
+  /**
+   * EP672-9: Internal method to start the tunnel process (Quick Tunnel mode)
+   * Separated from startTunnel to support reconnection
+   */
+  async startQuickTunnelProcess(options, existingState) {
     const { moduleUid, port = 3e3, onUrl, onStatusChange } = options;
     if (!this.cloudflaredPath) {
       try {
@@ -4419,7 +4743,7 @@ var TunnelManager = class extends import_events.EventEmitter {
           }
           resolve3({ success: false, error: errorMsg });
         }
-      }, 3e4);
+      }, TUNNEL_TIMEOUTS.QUICK_TUNNEL_CONNECT);
     });
   }
   /**
@@ -4446,9 +4770,11 @@ var TunnelManager = class extends import_events.EventEmitter {
    * EP877: Internal start implementation with lock already held
    * EP901: Enhanced to clean up ALL orphaned cloudflared processes before starting
    * EP904: Added port-based deduplication to prevent multiple tunnels on same port
+   * EP948: Added Named Tunnel provisioning via platform API
    */
   async startTunnelWithLock(options) {
     const { moduleUid, port = 3e3 } = options;
+    let resolvedOptions = { ...options };
     const existingState = this.tunnelStates.get(moduleUid);
     if (existingState) {
       if (existingState.info.status === "connected") {
@@ -4475,7 +4801,23 @@ var TunnelManager = class extends import_events.EventEmitter {
     if (cleanup.cleaned > 0) {
       console.log(`[Tunnel] EP901: Pre-start cleanup removed ${cleanup.cleaned} orphaned processes`);
     }
-    return this.startTunnelProcess(options);
+    const mode = resolvedOptions.mode || "named";
+    if (mode === "named" && !resolvedOptions.tunnelToken && moduleUid !== "LOCAL") {
+      console.log(`[Tunnel] EP948: Provisioning Named Tunnel for ${moduleUid}...`);
+      const provisionResult = await provisionNamedTunnelByUid(moduleUid);
+      if (provisionResult.success && provisionResult.tunnel) {
+        console.log(`[Tunnel] EP948: Named Tunnel provisioned: ${provisionResult.tunnel.preview_url}`);
+        resolvedOptions = {
+          ...resolvedOptions,
+          tunnelToken: provisionResult.tunnel.token,
+          previewUrl: provisionResult.tunnel.preview_url
+        };
+      } else {
+        console.warn(`[Tunnel] EP948: Named Tunnel provisioning failed: ${provisionResult.error}. Falling back to Quick Tunnel.`);
+        resolvedOptions = { ...resolvedOptions, mode: "quick" };
+      }
+    }
+    return this.startTunnelProcess(resolvedOptions);
   }
   /**
    * Stop a tunnel for a module
@@ -4574,28 +4916,6 @@ function getTunnelManager() {
   return tunnelManagerInstance;
 }
 
-// src/tunnel/tunnel-api.ts
-var import_core6 = __toESM(require_dist());
-async function clearTunnelUrl(moduleUid) {
-  if (!moduleUid || moduleUid === "LOCAL") {
-    return;
-  }
-  const config = await (0, import_core6.loadConfig)();
-  if (!config?.access_token) {
-    return;
-  }
-  try {
-    const apiUrl = config.api_url || "https://episoda.dev";
-    await fetch(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
-      method: "DELETE",
-      headers: {
-        "Authorization": `Bearer ${config.access_token}`
-      }
-    });
-  } catch {
-  }
-}
-
 // src/agent/claude-binary.ts
 var import_child_process7 = require("child_process");
 var path8 = __toESM(require("path"));
@@ -6892,10 +7212,17 @@ var Daemon = class _Daemon {
       serverUrl = config.project_settings.local_server_url;
       console.log(`[Daemon] Using cached server URL: ${serverUrl}`);
     }
-    const serverUrlObj = new URL(serverUrl);
-    const wsProtocol = serverUrlObj.protocol === "https:" ? "wss:" : "ws:";
-    const wsPort = process.env.EPISODA_WS_PORT || "3001";
-    const wsUrl = `${wsProtocol}//${serverUrlObj.hostname}:${wsPort}`;
+    let wsUrl;
+    if (config.ws_url) {
+      wsUrl = config.ws_url;
+      console.log(`[Daemon] Using configured ws_url: ${wsUrl}`);
+    } else {
+      const serverUrlObj = new URL(serverUrl);
+      const wsProtocol = serverUrlObj.protocol === "https:" ? "wss:" : "ws:";
+      const wsPort = process.env.EPISODA_WS_PORT || "3001";
+      const wsHostname = serverUrlObj.hostname === "episoda.dev" ? "ws.episoda.dev" : serverUrlObj.hostname;
+      wsUrl = `${wsProtocol}//${wsHostname}:${wsPort}`;
+    }
     console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
     const client = new import_core10.EpisodaClient();
     const gitExecutor = new import_core10.GitExecutor();