episoda 0.2.56 → 0.2.58

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.56",
+      version: "0.2.58",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -8787,6 +8787,9 @@ var Daemon = class _Daemon {
       this.reconcileWorktrees(projectId, projectPath, client).catch((err) => {
         console.warn("[Daemon] EP1003: Reconciliation report failed:", err.message);
       });
+      this.reconcilePendingCleanups(projectId, projectPath).catch((err) => {
+        console.warn("[Daemon] EP1047: Cleanup queue reconciliation failed:", err.message);
+      });
     });
     client.on("module_state_changed", async (message) => {
       if (message.type === "module_state_changed") {
@@ -9229,6 +9232,125 @@ 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
+   *
+   * On daemon startup/reconnect, fetch pending worktree cleanup tasks from the queue
+   * and process them. This catches any cleanups missed while the daemon was offline.
+   *
+   * 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.deviceId) {
+      console.log("[Daemon] EP1047: Cannot reconcile cleanups - deviceId not available yet");
+      return;
+    }
+    console.log(`[Daemon] EP1047: Checking for pending cleanup tasks for machine ${this.deviceId}`);
+    try {
+      const config = await (0, import_core12.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.deviceId}`,
+          { 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.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}`);
+    }
+  }
   /**
    * EP1002: Handle worktree_setup command from server
    * This provides a unified setup flow for both local and cloud environments.