episoda 0.2.13 → 0.2.15

package/dist/daemon/daemon-process.js

@@ -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) {
@@ -1827,6 +1839,32 @@ var require_websocket_client = __commonJS({
         }
         this.eventHandlers.get(event).push(handler);
       }
+      /**
+       * EP812: Register a one-time event handler (removes itself after first call)
+       * @param event - Event type
+       * @param handler - Handler function
+       */
+      once(event, handler) {
+        const onceHandler = (message) => {
+          this.off(event, onceHandler);
+          handler(message);
+        };
+        this.on(event, onceHandler);
+      }
+      /**
+       * EP812: Remove an event handler
+       * @param event - Event type
+       * @param handler - Handler function to remove
+       */
+      off(event, handler) {
+        const handlers = this.eventHandlers.get(event);
+        if (handlers) {
+          const index = handlers.indexOf(handler);
+          if (index !== -1) {
+            handlers.splice(index, 1);
+          }
+        }
+      }
       /**
        * Send a message to the server
        * @param message - Client message to send
@@ -1920,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;
@@ -2238,7 +2280,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.12",
+      version: "0.2.14",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3130,6 +3172,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();
   }
@@ -3198,18 +3244,31 @@ var Daemon = class {
     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;
@@ -3284,6 +3343,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);
     }
@@ -3310,6 +3382,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);
@@ -3405,6 +3478,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);
@@ -3447,6 +3521,23 @@ var Daemon = class {
       } 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 = 3e4;
+        const timeout = setTimeout(() => {
+          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);
+          resolve2();
+        };
+        client.once("auth_success", authHandler);
+        const errorHandler = (message) => {
+          clearTimeout(timeout);
+          const errorMsg = message;
+          reject(new Error(errorMsg.message || "Authentication failed"));
+        };
+        client.once("auth_error", errorHandler);
+      });
       await client.connect(wsUrl, config.access_token, this.machineId, {
         hostname: os.hostname(),
         osPlatform: os.platform(),
@@ -3454,9 +3545,12 @@ var Daemon = class {
         daemonPid
       });
       console.log(`[Daemon] Successfully connected to project ${projectId}`);
+      await authSuccessPromise;
+      console.log(`[Daemon] Authentication complete for project ${projectId}`);
     } catch (error) {
       console.error(`[Daemon] Failed to connect to ${projectId}:`, error);
       this.connections.delete(projectPath);
+      this.pendingConnections.delete(projectPath);
       throw error;
     }
   }
@@ -3474,6 +3568,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}`);
   }
   /**