episoda 0.2.31 → 0.2.33

package/dist/daemon/daemon-process.js

@@ -1635,6 +1635,9 @@ var require_git_executor = __commonJS({
           const args = ["worktree", "add"];
           if (command.create) {
             args.push("-b", command.branch, command.path);
+            if (command.startPoint) {
+              args.push(command.startPoint);
+            }
           } else {
             args.push(command.path, command.branch);
           }
@@ -2696,7 +2699,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.30",
+      version: "0.2.32",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -5533,14 +5536,19 @@ var WorktreeManager = class _WorktreeManager {
         action: "fetch",
         remote: "origin"
       }, { cwd: this.bareRepoPath });
-      if (!fetchResult.success) {
-        console.warn("[worktree-manager] Failed to fetch from origin:", fetchResult.output);
+      if (!fetchResult.success && createBranch) {
+        console.error("[worktree-manager] Failed to fetch from origin:", fetchResult.output);
+        return {
+          success: false,
+          error: "Failed to fetch latest refs from origin. Cannot create worktree with stale refs."
+        };
       }
       const result = await this.gitExecutor.execute({
         action: "worktree_add",
         path: worktreePath,
         branch: branchName,
-        create: createBranch
+        create: createBranch,
+        startPoint: createBranch ? "origin/main" : void 0
       }, { cwd: this.bareRepoPath });
       if (!result.success) {
         return {
@@ -7150,6 +7158,9 @@ var Daemon = class _Daemon {
       this.syncProjectSettings(projectId).catch((err) => {
         console.warn("[Daemon] EP964: Settings sync failed:", err.message);
       });
+      this.syncMachineProjectPath(projectId, projectPath).catch((err) => {
+        console.warn("[Daemon] EP995: Project path sync failed:", err.message);
+      });
       this.autoStartTunnelsForProject(projectPath, projectId).catch((error) => {
         console.error(`[Daemon] EP819: Failed to auto-start tunnels:`, error);
       });
@@ -7160,6 +7171,9 @@ var Daemon = class _Daemon {
       }).catch((err) => {
         console.warn("[Daemon] EP950: Cleanup on connect failed:", err.message);
       });
+      this.reconcileWorktrees(projectId, projectPath).catch((err) => {
+        console.warn("[Daemon] EP995: Reconciliation failed:", err.message);
+      });
     });
     client.on("module_state_changed", async (message) => {
       if (message.type === "module_state_changed") {
@@ -7243,6 +7257,7 @@ var Daemon = class _Daemon {
                 {
                   console.log(`[Daemon] EP986: Starting async worktree setup for ${moduleUid}${hasSetupConfig ? " (with config)" : " (for dependency installation)"}`);
                   await worktreeManager.updateWorktreeStatus(moduleUid, "pending");
+                  await this.updateModuleWorktreeStatus(moduleUid, "pending", worktree.path);
                   this.runWorktreeSetupAsync(
                     moduleUid,
                     worktreeManager,
@@ -7575,6 +7590,189 @@ var Daemon = class _Daemon {
       console.warn("[Daemon] EP964: Failed to sync project settings:", error instanceof Error ? error.message : error);
     }
   }
+  /**
+   * EP995: Sync project path to server (local_machine.project_paths)
+   *
+   * Reports the local filesystem path for this project to the server,
+   * enabling server-side visibility into where projects are checked out.
+   * Uses atomic RPC to prevent race conditions.
+   */
+  async syncMachineProjectPath(projectId, projectPath) {
+    try {
+      if (!this.deviceId) {
+        console.warn("[Daemon] EP995: Cannot sync project path - deviceId not available");
+        return;
+      }
+      const config = await (0, import_core10.loadConfig)();
+      if (!config) return;
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const response = await fetchWithAuth(`${apiUrl}/api/account/machines/${this.deviceId}`, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          project_id: projectId,
+          project_path: projectPath
+        })
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        console.warn(`[Daemon] EP995: Failed to sync project path: ${response.status}`, errorData);
+        return;
+      }
+      console.log(`[Daemon] EP995: Synced project path to server: ${projectPath}`);
+    } catch (error) {
+      console.warn("[Daemon] EP995: Failed to sync project path:", error instanceof Error ? error.message : error);
+    }
+  }
+  /**
+   * EP995: Update module worktree status on server
+   *
+   * Reports worktree setup progress to the server, enabling:
+   * - Server-side visibility into worktree state
+   * - UI progress display (compatible with EP978)
+   * - Reconciliation queries on daemon reconnect
+   */
+  async updateModuleWorktreeStatus(moduleUid, status, worktreePath, errorMessage) {
+    try {
+      const config = await (0, import_core10.loadConfig)();
+      if (!config) return;
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const body = {
+        worktree_status: status
+      };
+      if (worktreePath) {
+        body.worktree_path = worktreePath;
+      }
+      if (status === "error" && errorMessage) {
+        body.worktree_error = errorMessage;
+      }
+      if (status !== "error") {
+        body.worktree_error = null;
+      }
+      const response = await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}`, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify(body)
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        console.warn(`[Daemon] EP995: Failed to update worktree status: ${response.status}`, errorData);
+        return;
+      }
+      console.log(`[Daemon] EP995: Updated module ${moduleUid} worktree_status=${status}`);
+    } catch (error) {
+      console.warn("[Daemon] EP995: Failed to update worktree status:", error instanceof Error ? error.message : error);
+    }
+  }
+  /**
+   * EP995: Reconcile worktrees on daemon connect/reconnect
+   *
+   * Figma-style "fresh snapshot on reconnect" approach:
+   * 1. Query server for modules that should have worktrees on this machine
+   * 2. For modules missing local worktrees, create and setup
+   * 3. Log orphaned worktrees (local exists but module not in doing/review)
+   *
+   * This self-healing mechanism catches modules that transitioned
+   * while the daemon was disconnected.
+   */
+  async reconcileWorktrees(projectId, projectPath) {
+    console.log(`[Daemon] EP995: Starting worktree reconciliation for project ${projectId}`);
+    try {
+      if (!this.deviceId) {
+        console.log("[Daemon] EP995: Cannot reconcile - deviceId not available yet");
+        return;
+      }
+      const config = await (0, import_core10.loadConfig)();
+      if (!config) return;
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const modulesResponse = await fetchWithAuth(
+        `${apiUrl}/api/modules?state=doing,review&dev_mode=local&checkout_machine_id=${this.deviceId}&project_id=${projectId}`
+      );
+      if (!modulesResponse.ok) {
+        console.warn(`[Daemon] EP995: Failed to fetch modules for reconciliation: ${modulesResponse.status}`);
+        return;
+      }
+      const modulesData = await modulesResponse.json();
+      const modules = modulesData.modules || [];
+      if (modules.length === 0) {
+        console.log("[Daemon] EP995: No modules need reconciliation");
+        return;
+      }
+      console.log(`[Daemon] EP995: Found ${modules.length} module(s) to check`);
+      const worktreeManager = new WorktreeManager(projectPath);
+      const initialized = await worktreeManager.initialize();
+      if (!initialized) {
+        console.error(`[Daemon] EP995: Failed to initialize WorktreeManager`);
+        return;
+      }
+      for (const module2 of modules) {
+        const moduleUid = module2.uid;
+        const branchName = module2.branch_name;
+        const worktree = await getWorktreeInfoForModule(moduleUid);
+        if (!worktree?.exists) {
+          console.log(`[Daemon] EP995: Module ${moduleUid} missing local worktree - creating...`);
+          const moduleBranchName = branchName || moduleUid;
+          const createResult = await worktreeManager.createWorktree(moduleUid, moduleBranchName, true);
+          if (!createResult.success) {
+            console.error(`[Daemon] EP995: Failed to create worktree for ${moduleUid}: ${createResult.error}`);
+            continue;
+          }
+          console.log(`[Daemon] EP995: Created worktree for ${moduleUid} at ${createResult.worktreePath}`);
+          if (this.deviceId) {
+            try {
+              await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}`, {
+                method: "PATCH",
+                body: JSON.stringify({ checkout_machine_id: this.deviceId })
+              });
+              console.log(`[Daemon] EP995: Claimed ownership of ${moduleUid}`);
+            } catch (ownershipError) {
+              console.warn(`[Daemon] EP995: Failed to claim ownership of ${moduleUid}`);
+            }
+          }
+          const newWorktree = await getWorktreeInfoForModule(moduleUid);
+          if (!newWorktree?.exists) {
+            console.error(`[Daemon] EP995: Worktree still not found after creation`);
+            continue;
+          }
+          const setupConfig = config.project_settings;
+          const envVars = await fetchEnvVars();
+          console.log(`[Daemon] EP995: Starting setup for reconciled module ${moduleUid}`);
+          await worktreeManager.updateWorktreeStatus(moduleUid, "pending");
+          await this.updateModuleWorktreeStatus(moduleUid, "pending", newWorktree.path);
+          this.runWorktreeSetupAsync(
+            moduleUid,
+            worktreeManager,
+            setupConfig?.worktree_copy_files || [],
+            setupConfig?.worktree_setup_script,
+            newWorktree.path,
+            envVars
+          ).then(() => {
+            console.log(`[Daemon] EP995: Setup complete for reconciled ${moduleUid}`);
+            this.startTunnelForModule(moduleUid, newWorktree.path);
+          }).catch((err) => {
+            console.error(`[Daemon] EP995: Setup failed for reconciled ${moduleUid}:`, err);
+          });
+        } else {
+          const tunnelManager = getTunnelManager();
+          await tunnelManager.initialize();
+          if (!tunnelManager.hasTunnel(moduleUid)) {
+            console.log(`[Daemon] EP995: Module ${moduleUid} has worktree but no tunnel - starting...`);
+            await this.startTunnelForModule(moduleUid, worktree.path);
+          } else {
+            console.log(`[Daemon] EP995: Module ${moduleUid} OK - worktree and tunnel exist`);
+          }
+        }
+      }
+      console.log("[Daemon] EP995: Reconciliation complete");
+    } catch (error) {
+      console.error("[Daemon] EP995: Reconciliation error:", error instanceof Error ? error.message : error);
+      throw error;
+    }
+  }
   /**
    * EP956: Cleanup module worktree when module moves to done
    *
@@ -7614,6 +7812,22 @@ var Daemon = class _Daemon {
       } else {
         console.log(`[Daemon] EP994: No worktree to remove for ${moduleUid}`);
       }
+      try {
+        const cleanupConfig = await (0, import_core10.loadConfig)();
+        const cleanupApiUrl = cleanupConfig?.api_url || "https://episoda.dev";
+        await fetchWithAuth(`${cleanupApiUrl}/api/modules/${moduleUid}`, {
+          method: "PATCH",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            worktree_status: null,
+            worktree_path: null,
+            worktree_error: null
+          })
+        });
+        console.log(`[Daemon] EP995: Cleared worktree status for ${moduleUid}`);
+      } catch (clearError) {
+        console.warn(`[Daemon] EP995: Failed to clear worktree status for ${moduleUid}:`, clearError);
+      }
       console.log(`[Daemon] EP956: Async cleanup complete for ${moduleUid}`);
     } catch (error) {
       console.error(`[Daemon] EP956: Cleanup error for ${moduleUid}:`, error instanceof Error ? error.message : error);
@@ -7629,6 +7843,7 @@ var Daemon = class _Daemon {
     console.log(`[Daemon] EP959: Running async worktree setup for ${moduleUid}`);
     try {
       await worktreeManager.updateWorktreeStatus(moduleUid, "running");
+      await this.updateModuleWorktreeStatus(moduleUid, "setup", worktreePath);
       if (Object.keys(envVars).length > 0) {
         console.log(`[Daemon] EP988: Writing .env with ${Object.keys(envVars).length} variables to ${moduleUid}`);
         writeEnvFile(worktreePath, envVars);
@@ -7672,11 +7887,13 @@ var Daemon = class _Daemon {
         }
       }
       await worktreeManager.updateWorktreeStatus(moduleUid, "ready");
+      await this.updateModuleWorktreeStatus(moduleUid, "ready", worktreePath);
       console.log(`[Daemon] EP959: Worktree setup complete for ${moduleUid}`);
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
       console.error(`[Daemon] EP959: Worktree setup failed for ${moduleUid}:`, errorMessage);
       await worktreeManager.updateWorktreeStatus(moduleUid, "error", errorMessage);
+      await this.updateModuleWorktreeStatus(moduleUid, "error", worktreePath, errorMessage);
       throw error;
     }
   }