episoda 0.2.55 → 0.2.57

package/dist/daemon/daemon-process.js

@@ -2319,6 +2319,14 @@ var require_websocket_client = __commonJS({
           connected: this.isConnected
         };
       }
+      /**
+       * EP949: Update the access token (used when server sends token_refresh message)
+       * This updates the in-memory token used for reconnection.
+       */
+      updateToken(newToken) {
+        console.log("[EpisodaClient] EP949: Access token updated");
+        this.token = newToken;
+      }
       /**
        * EP605: Update last command time to reset idle detection
        * Call this when a command is received/executed
@@ -2718,7 +2726,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.55",
+      version: "0.2.57",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -8779,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") {
@@ -8802,6 +8813,11 @@ var Daemon = class _Daemon {
     client.on("error", (message) => {
       console.error(`[Daemon] Server error for ${projectId}:`, message);
     });
+    client.on("token_refresh", (message) => {
+      const tokenMsg = message;
+      console.log(`[Daemon] EP949: Received token refresh for ${projectId}`);
+      client.updateToken(tokenMsg.accessToken);
+    });
     client.on("disconnected", (event) => {
       const disconnectEvent = event;
       console.log(`[Daemon] Connection closed for ${projectId}: code=${disconnectEvent.code}, willReconnect=${disconnectEvent.willReconnect}`);
@@ -9216,6 +9232,117 @@ 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/cleanup-queue?machine_id=${this.deviceId}`,
+          { signal: controller.signal }
+        );
+      } finally {
+        clearTimeout(timeoutId);
+      }
+      if (!response.ok) {
+        console.warn(`[Daemon] EP1047: Failed to fetch cleanup tasks: ${response.status}`);
+        return;
+      }
+      const data = await response.json();
+      const tasks = data.data?.tasks || [];
+      if (tasks.length === 0) {
+        console.log("[Daemon] EP1047: No pending cleanup tasks");
+        return;
+      }
+      console.log(`[Daemon] EP1047: Processing ${tasks.length} pending cleanup task(s)`);
+      const projectRoot = await findProjectRoot(projectPath);
+      if (!projectRoot) {
+        console.warn("[Daemon] EP1047: Could not find project root, skipping cleanup reconciliation");
+        return;
+      }
+      const worktreeManager = new WorktreeManager(projectRoot);
+      if (!await worktreeManager.initialize()) {
+        console.warn("[Daemon] EP1047: Failed to initialize worktree manager");
+        return;
+      }
+      for (const task of tasks) {
+        const moduleUid = task.payload.module_uid || task.target_id;
+        console.log(`[Daemon] EP1047: Processing cleanup for ${moduleUid} (task ${task.id})`);
+        try {
+          const result = await worktreeManager.removeWorktree(moduleUid, true);
+          if (result.success) {
+            console.log(`[Daemon] EP1047: Successfully cleaned up worktree for ${moduleUid}`);
+            await this.reportCleanupResult(apiUrl, task.id, "complete");
+          } else {
+            if (result.error?.includes("not found") || result.error?.includes("No worktree found")) {
+              console.log(`[Daemon] EP1047: Worktree ${moduleUid} already removed, marking complete`);
+              await this.reportCleanupResult(apiUrl, task.id, "complete");
+            } else {
+              console.warn(`[Daemon] EP1047: Cleanup failed for ${moduleUid}: ${result.error}`);
+              await this.reportCleanupResult(apiUrl, task.id, "retry", {
+                code: "CLEANUP_ERROR",
+                message: result.error || "Unknown error"
+              });
+            }
+          }
+        } catch (error) {
+          console.error(`[Daemon] EP1047: Error processing cleanup for ${moduleUid}:`, error.message);
+          await this.reportCleanupResult(apiUrl, task.id, "retry", {
+            code: "CLEANUP_EXCEPTION",
+            message: error.message
+          });
+        }
+      }
+      console.log("[Daemon] EP1047: Cleanup reconciliation complete");
+    } catch (error) {
+      console.error("[Daemon] EP1047: Cleanup reconciliation error:", error instanceof Error ? error.message : error);
+      throw error;
+    }
+  }
+  /**
+   * EP1047: Report cleanup task result to server
+   */
+  async reportCleanupResult(apiUrl, taskId, action, error) {
+    try {
+      const response = await fetchWithAuth(`${apiUrl}/api/cli/cleanup-queue`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          task_id: taskId,
+          action,
+          error
+        })
+      });
+      if (!response.ok) {
+        console.warn(`[Daemon] EP1047: Failed to report cleanup result: ${response.status}`);
+      }
+    } catch (err) {
+      console.warn(`[Daemon] EP1047: Error reporting cleanup result: ${err.message}`);
+    }
+  }
   /**
    * EP1002: Handle worktree_setup command from server
    * This provides a unified setup flow for both local and cloud environments.