episoda 0.2.97 → 0.2.99

package/dist/daemon/daemon-process.js

@@ -2786,7 +2786,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.97",
+      version: "0.2.99",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -4406,6 +4406,48 @@ var WorktreeManager = class _WorktreeManager {
     }
     return { valid, stale, orphaned };
   }
+  /**
+   * EP1190: Clean up non-module worktrees (like 'main')
+   *
+   * In K1273 per-user-per-workspace model, only EP### worktrees should exist.
+   * The 'main' worktree and other non-module worktrees are legacy artifacts
+   * that can contain stale code and should be removed.
+   *
+   * @returns Object with removed paths and errors
+   */
+  async cleanupNonModuleWorktrees() {
+    const removed = [];
+    const errors = [];
+    try {
+      const validation = await this.validateWorktrees();
+      for (const orphanPath of validation.orphaned) {
+        const dirName = path7.basename(orphanPath);
+        const isModuleWorktree = /^EP\d+$/.test(dirName);
+        if (!isModuleWorktree) {
+          console.log(`[WorktreeManager] EP1190: Found non-module worktree: ${dirName}`);
+          try {
+            const removeResult = await this.gitExecutor.execute({
+              action: "worktree_remove",
+              path: orphanPath,
+              force: true
+              // Force removal since it's not tracked
+            }, { cwd: this.bareRepoPath });
+            if (removeResult.success) {
+              removed.push(dirName);
+              console.log(`[WorktreeManager] EP1190: Removed non-module worktree: ${dirName}`);
+            } else {
+              errors.push(`Failed to remove ${dirName}: ${removeResult.output}`);
+            }
+          } catch (removeError) {
+            errors.push(`Error removing ${dirName}: ${removeError.message}`);
+          }
+        }
+      }
+    } catch (error) {
+      errors.push(`Validation error: ${error.message}`);
+    }
+    return { removed, errors };
+  }
   /**
    * Get project configuration
    */
@@ -9425,7 +9467,6 @@ async function fetchEnvVars2() {
   }
 }
 var Daemon = class _Daemon {
-  // 60 seconds
   constructor() {
     this.machineId = "";
     this.machineUuid = null;
@@ -9464,6 +9505,9 @@ var Daemon = class _Daemon {
     // Health checks are orthogonal to push-based state sync - they detect dead tunnels
     this.healthCheckInterval = null;
     this.healthCheckInProgress = false;
+    // 60 seconds
+    // EP1190: Worktree cleanup runs every N health checks (5 * 60s = 5 minutes)
+    this.healthCheckCounter = 0;
     this.ipcServer = new IPCServer();
   }
   static {
@@ -9480,6 +9524,9 @@ var Daemon = class _Daemon {
   static {
     this.HEALTH_CHECK_INTERVAL_MS = 6e4;
   }
+  static {
+    this.WORKTREE_CLEANUP_EVERY_N_CHECKS = 5;
+  }
   /**
    * Start the daemon
    */
@@ -10877,130 +10924,8 @@ var Daemon = class _Daemon {
     }
   }
   // EP1025: Removed cleanupModuleWorktree - was dead code (never called).
-  // Worktree cleanup is handled by server's cleanupWorktreeAsync which sends
-  // worktree_remove command via WebSocket, handled by GitExecutor.executeWorktreeRemove.
-  /**
-   * EP1047: Process pending cleanup queue entries for this machine
-   *
-   * @deprecated EP1091: No longer called on connect. Server-side cron now processes
-   * the cleanup queue and sends WebSocket commands to connected daemons. This is
-   * more reliable than daemon-side polling since it works even if daemon stays connected.
-   *
-   * Kept for potential manual invocation or debugging purposes.
-   *
-   * Flow:
-   * 1. Query server for pending cleanup tasks for this machine
-   * 2. For each task, attempt worktree removal
-   * 3. Report success/failure back to server
-   */
-  async reconcilePendingCleanups(projectId, projectPath) {
-    if (!this.machineUuid) {
-      console.log("[Daemon] EP1047: Cannot reconcile cleanups - machineUuid not available yet");
-      return;
-    }
-    console.log(`[Daemon] EP1047: Checking for pending cleanup tasks for machine ${this.machineUuid}`);
-    try {
-      const config = await (0, import_core13.loadConfig)();
-      if (!config) {
-        console.log("[Daemon] EP1047: No config loaded, skipping cleanup reconciliation");
-        return;
-      }
-      const apiUrl = config.api_url || "https://episoda.dev";
-      const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), 1e4);
-      let response;
-      try {
-        response = await fetchWithAuth(
-          `${apiUrl}/api/cli/background-ops?machine_id=${this.machineUuid}`,
-          { signal: controller.signal }
-        );
-      } finally {
-        clearTimeout(timeoutId);
-      }
-      if (!response.ok) {
-        console.warn(`[Daemon] EP1051: Failed to fetch background operations: ${response.status}`);
-        return;
-      }
-      const data = await response.json();
-      const tasks = data.tasks || [];
-      if (tasks.length === 0) {
-        console.log("[Daemon] EP1051: No pending background operations");
-        return;
-      }
-      console.log(`[Daemon] EP1051: Processing ${tasks.length} pending operation(s)`);
-      const projectRoot = await findProjectRoot(projectPath);
-      if (!projectRoot) {
-        console.warn("[Daemon] EP1051: Could not find project root, skipping operation reconciliation");
-        return;
-      }
-      const worktreeManager = new WorktreeManager(projectRoot);
-      if (!await worktreeManager.initialize()) {
-        console.warn("[Daemon] EP1051: Failed to initialize worktree manager");
-        return;
-      }
-      for (const task of tasks) {
-        const moduleUid = task.payload.module_uid || task.target_id;
-        console.log(`[Daemon] EP1051: Processing ${task.operation_type} for ${moduleUid} (task ${task.id})`);
-        try {
-          if (task.operation_type === "worktree_cleanup") {
-            const result = await worktreeManager.removeWorktree(moduleUid, true);
-            if (result.success) {
-              console.log(`[Daemon] EP1051: Successfully cleaned up worktree for ${moduleUid}`);
-              await this.reportOperationResult(apiUrl, task.id, "complete");
-            } else {
-              if (result.error?.includes("not found") || result.error?.includes("No worktree found")) {
-                console.log(`[Daemon] EP1051: Worktree ${moduleUid} already removed, marking complete`);
-                await this.reportOperationResult(apiUrl, task.id, "complete");
-              } else {
-                console.warn(`[Daemon] EP1051: Cleanup failed for ${moduleUid}: ${result.error}`);
-                await this.reportOperationResult(apiUrl, task.id, "retry", {
-                  code: "OPERATION_ERROR",
-                  message: result.error || "Unknown error"
-                });
-              }
-            }
-          } else {
-            console.warn(`[Daemon] EP1051: Unknown operation type: ${task.operation_type}`);
-            await this.reportOperationResult(apiUrl, task.id, "fail", {
-              code: "UNKNOWN_OPERATION_TYPE",
-              message: `Daemon cannot process operation type: ${task.operation_type}`
-            });
-          }
-        } catch (error) {
-          console.error(`[Daemon] EP1051: Error processing operation for ${moduleUid}:`, error.message);
-          await this.reportOperationResult(apiUrl, task.id, "retry", {
-            code: "OPERATION_EXCEPTION",
-            message: error.message
-          });
-        }
-      }
-      console.log("[Daemon] EP1051: Operation reconciliation complete");
-    } catch (error) {
-      console.error("[Daemon] EP1051: Operation reconciliation error:", error instanceof Error ? error.message : error);
-      throw error;
-    }
-  }
-  /**
-   * EP1051: Report background operation result to server
-   */
-  async reportOperationResult(apiUrl, taskId, action, error) {
-    try {
-      const response = await fetchWithAuth(`${apiUrl}/api/cli/background-ops`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-          task_id: taskId,
-          action,
-          error
-        })
-      });
-      if (!response.ok) {
-        console.warn(`[Daemon] EP1051: Failed to report operation result: ${response.status}`);
-      }
-    } catch (err) {
-      console.warn(`[Daemon] EP1051: Error reporting operation result: ${err.message}`);
-    }
-  }
+  // EP1188: Background ops queue removed - worktree cleanup now handled by Inngest events
+  // (worktree/cleanup) which send WebSocket commands to connected daemons via ws-proxy.
   /**
    * EP1002: Handle worktree_setup command from server
    * This provides a unified setup flow for both local and cloud environments.
@@ -11217,6 +11142,11 @@ var Daemon = class _Daemon {
         if (config?.access_token) {
           await this.performHealthChecks(config);
         }
+        this.healthCheckCounter++;
+        if (this.healthCheckCounter >= _Daemon.WORKTREE_CLEANUP_EVERY_N_CHECKS) {
+          this.healthCheckCounter = 0;
+          await this.auditWorktreesOnStartup();
+        }
       } catch (error) {
         console.error("[Daemon] EP929: Health check error:", error instanceof Error ? error.message : error);
       } finally {
@@ -11403,6 +11333,19 @@ var Daemon = class _Daemon {
           console.warn("[Daemon] EP1035: Failed to prune stale worktrees:", pruneError.message);
         }
       }
+      try {
+        const cleanupResult = await manager.cleanupNonModuleWorktrees();
+        if (cleanupResult.removed.length > 0) {
+          console.log(`[Daemon] EP1190: Cleaned up ${cleanupResult.removed.length} non-module worktree(s): ${cleanupResult.removed.join(", ")}`);
+        }
+        if (cleanupResult.errors.length > 0) {
+          for (const err of cleanupResult.errors) {
+            console.warn(`[Daemon] EP1190: Non-module cleanup error: ${err}`);
+          }
+        }
+      } catch (cleanupError) {
+        console.warn("[Daemon] EP1190: Failed to cleanup non-module worktrees:", cleanupError.message);
+      }
     } catch (error) {
       console.warn(`[Daemon] EP1035: Failed to audit ${projectPath}:`, error);
     }