episoda 0.2.35 → 0.2.36

package/dist/daemon/daemon-process.js

@@ -397,6 +397,9 @@ var require_git_executor = __commonJS({
               return await this.executeWorktreeList(cwd, options);
             case "worktree_prune":
               return await this.executeWorktreePrune(cwd, options);
+            // EP1002: Worktree setup command for unified orchestration
+            case "worktree_setup":
+              return await this.executeWorktreeSetup(command, cwd, options);
             case "clone_bare":
               return await this.executeCloneBare(command, options);
             case "project_info":
@@ -1710,6 +1713,10 @@ var require_git_executor = __commonJS({
           args.push(command.path);
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
+            try {
+              await fs17.rm(command.path, { recursive: true, force: true });
+            } catch {
+            }
             return {
               success: true,
               output: `Removed worktree at ${command.path}`,
@@ -1823,6 +1830,18 @@ var require_git_executor = __commonJS({
           };
         }
       }
+      /**
+       * EP1002: Worktree setup command stub
+       * The actual implementation is in the daemon which intercepts this command.
+       * This stub exists for type checking and as a fallback.
+       */
+      async executeWorktreeSetup(command, cwd, options) {
+        return {
+          success: false,
+          error: "NOT_IMPLEMENTED",
+          output: "worktree_setup must be handled by the daemon, not GitExecutor"
+        };
+      }
       /**
        * EP944: Clone a repository as a bare repository
        * Used for worktree-based development setup
@@ -2593,6 +2612,9 @@ var require_errors = __commonJS({
         "WORKTREE_NOT_FOUND": "Worktree not found at this path",
         "WORKTREE_LOCKED": "Worktree is locked",
         "BRANCH_IN_USE": "Branch is already checked out in another worktree",
+        // EP1002: Worktree setup error messages
+        "NOT_IMPLEMENTED": "Command not implemented in this context",
+        "SETUP_FAILED": "Worktree setup failed",
         "UNKNOWN_ERROR": "Unknown error occurred"
       };
       let message = messages[code] || `Error: ${code}`;
@@ -2699,7 +2721,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.34",
+      version: "0.2.35",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -6242,17 +6264,6 @@ async function getWorktreeInfoForModule(moduleUid) {
   }
   return getWorktreeInfo(moduleUid, config.workspace_slug, config.project_slug);
 }
-async function getProjectRootPath() {
-  const config = await (0, import_core9.loadConfig)();
-  if (!config?.workspace_slug || !config?.project_slug) {
-    return null;
-  }
-  return path15.join(
-    getEpisodaRoot2(),
-    config.workspace_slug,
-    config.project_slug
-  );
-}
 
 // src/utils/port-allocator.ts
 var PORT_RANGE_START = 3100;
@@ -6898,6 +6909,32 @@ var Daemon = class _Daemon {
           } else {
             console.log(`[Daemon] Running git command in bare repo: ${bareRepoPath}`);
           }
+          if (gitCmd.action === "worktree_setup") {
+            const wtManager = new WorktreeManager(projectPath);
+            await wtManager.initialize();
+            const SETUP_TIMEOUT_MS = 15 * 60 * 1e3;
+            const setupPromise = this.handleWorktreeSetup(gitCmd, projectPath, wtManager);
+            const timeoutPromise = new Promise(
+              (_, reject) => setTimeout(() => reject(new Error("Worktree setup timed out after 15 minutes")), SETUP_TIMEOUT_MS)
+            );
+            let setupResult;
+            try {
+              setupResult = await Promise.race([setupPromise, timeoutPromise]);
+            } catch (timeoutError) {
+              setupResult = {
+                success: false,
+                error: "COMMAND_TIMEOUT",
+                output: timeoutError instanceof Error ? timeoutError.message : "Setup timed out"
+              };
+            }
+            await client.send({
+              type: "result",
+              commandId: message.id,
+              result: setupResult
+            });
+            console.log(`[Daemon] EP1002: Worktree setup completed for ${gitCmd.moduleUid}:`, setupResult.success ? "success" : "failed");
+            return;
+          }
           const result = await gitExecutor.execute(gitCmd, {
             cwd
           });
@@ -7367,74 +7404,6 @@ var Daemon = class _Daemon {
                 console.error(`[Daemon] EP956: Cannot resolve worktree path for ${moduleUid} (missing config slugs)`);
                 return;
               }
-              if (!worktree.exists && startingWork) {
-                console.log(`[Daemon] EP959: Creating worktree for ${moduleUid} at ${worktree.path}`);
-                const projectRoot = await getProjectRootPath();
-                if (!projectRoot) {
-                  console.error(`[Daemon] EP959: Cannot determine project root for worktree creation`);
-                  return;
-                }
-                const worktreeManager = new WorktreeManager(projectRoot);
-                const initialized = await worktreeManager.initialize();
-                if (!initialized) {
-                  console.error(`[Daemon] EP959: Failed to initialize WorktreeManager at ${projectRoot}`);
-                  return;
-                }
-                const moduleBranchName = branchName || moduleUid;
-                const createResult = await worktreeManager.createWorktree(moduleUid, moduleBranchName, true);
-                if (!createResult.success) {
-                  console.error(`[Daemon] EP959: Failed to create worktree for ${moduleUid}: ${createResult.error}`);
-                  return;
-                }
-                console.log(`[Daemon] EP959: Worktree created for ${moduleUid} at ${createResult.worktreePath}`);
-                if (this.deviceId) {
-                  try {
-                    const ownershipConfig = await (0, import_core10.loadConfig)();
-                    const ownershipApiUrl = ownershipConfig?.api_url || "https://episoda.dev";
-                    const ownershipResponse = await fetchWithAuth(`${ownershipApiUrl}/api/modules/${moduleUid}`, {
-                      method: "PATCH",
-                      body: JSON.stringify({ checkout_machine_id: this.deviceId })
-                    });
-                    if (ownershipResponse.ok) {
-                      console.log(`[Daemon] EP990: Claimed ownership of ${moduleUid} for device ${this.deviceId}`);
-                    } else {
-                      console.warn(`[Daemon] EP990: Failed to claim ownership of ${moduleUid}: ${ownershipResponse.status}`);
-                    }
-                  } catch (ownershipError) {
-                    console.warn(`[Daemon] EP990: Error claiming ownership of ${moduleUid}:`, ownershipError);
-                  }
-                }
-                worktree = await getWorktreeInfoForModule(moduleUid);
-                if (!worktree || !worktree.exists) {
-                  console.error(`[Daemon] EP959: Worktree still not found after creation for ${moduleUid}`);
-                  return;
-                }
-                const worktreeConfig = await (0, import_core10.loadConfig)();
-                const setupConfig = worktreeConfig?.project_settings;
-                const envVars = await fetchEnvVars2();
-                const hasEnvVars = Object.keys(envVars).length > 0;
-                const hasSetupConfig = setupConfig?.worktree_copy_files?.length || setupConfig?.worktree_setup_script || hasEnvVars;
-                {
-                  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,
-                    setupConfig?.worktree_copy_files || [],
-                    setupConfig?.worktree_setup_script,
-                    worktree.path,
-                    envVars
-                    // EP973: Use server-fetched env vars
-                  ).then(() => {
-                    console.log(`[Daemon] EP959: Setup complete for ${moduleUid}, starting tunnel`);
-                    this.startTunnelForModule(moduleUid, worktree.path);
-                  }).catch((err) => {
-                    console.error(`[Daemon] EP959: Setup failed for ${moduleUid}:`, err);
-                  });
-                  return;
-                }
-              }
               if (!worktree.exists) {
                 console.log(`[Daemon] EP956: No worktree for ${moduleUid} at ${worktree.path}, skipping tunnel`);
                 return;
@@ -7996,6 +7965,90 @@ var Daemon = class _Daemon {
       throw error;
     }
   }
+  /**
+   * EP1002: Handle worktree_setup command from server
+   * This provides a unified setup flow for both local and cloud environments.
+   * Server orchestrates, daemon executes.
+   */
+  async handleWorktreeSetup(command, projectPath, worktreeManager) {
+    const { path: worktreePath, moduleUid } = command;
+    console.log(`[Daemon] EP1002: Handling worktree_setup for ${moduleUid} at ${worktreePath}`);
+    try {
+      const envVars = await fetchEnvVars2();
+      console.log(`[Daemon] EP1002: Fetched ${Object.keys(envVars).length} env vars for ${moduleUid}`);
+      const config = await (0, import_core10.loadConfig)();
+      const setupConfig = config?.project_settings;
+      await this.runWorktreeSetupSync(
+        moduleUid,
+        worktreeManager,
+        setupConfig?.worktree_copy_files || [],
+        setupConfig?.worktree_setup_script,
+        worktreePath,
+        envVars
+      );
+      return {
+        success: true,
+        output: `Worktree setup completed for ${moduleUid}`,
+        details: {
+          moduleUid,
+          worktreePath,
+          envVarsCount: Object.keys(envVars).length
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[Daemon] EP1002: Worktree setup failed for ${moduleUid}:`, errorMessage);
+      return {
+        success: false,
+        error: "SETUP_FAILED",
+        output: errorMessage
+      };
+    }
+  }
+  /**
+   * EP1002: Synchronous worktree setup for command-driven flow
+   * Similar to runWorktreeSetupAsync but runs synchronously for server orchestration
+   */
+  async runWorktreeSetupSync(moduleUid, worktreeManager, copyFiles, setupScript, worktreePath, envVars = {}) {
+    console.log(`[Daemon] EP1002: Running worktree setup for ${moduleUid}`);
+    await worktreeManager.updateWorktreeStatus(moduleUid, "running");
+    await this.updateModuleWorktreeStatus(moduleUid, "setup", worktreePath);
+    if (Object.keys(envVars).length > 0) {
+      console.log(`[Daemon] EP1002: Writing .env with ${Object.keys(envVars).length} variables`);
+      writeEnvFile(worktreePath, envVars);
+    }
+    const installCmd = getInstallCommand(worktreePath);
+    if (installCmd) {
+      console.log(`[Daemon] EP1002: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
+      console.log(`[Daemon] EP1002: Running: ${installCmd.command.join(" ")}`);
+      try {
+        const { execSync: execSync7 } = await import("child_process");
+        execSync7(installCmd.command.join(" "), {
+          cwd: worktreePath,
+          stdio: "inherit",
+          timeout: 10 * 60 * 1e3,
+          // 10 minute timeout
+          env: { ...process.env, CI: "true" }
+        });
+        console.log(`[Daemon] EP1002: Dependencies installed successfully`);
+      } catch (installError) {
+        const errorMsg = installError instanceof Error ? installError.message : String(installError);
+        console.warn(`[Daemon] EP1002: Dependency installation failed (non-fatal): ${errorMsg}`);
+      }
+    } else {
+      console.log(`[Daemon] EP1002: No package manager detected, skipping dependency installation`);
+    }
+    if (setupScript) {
+      console.log(`[Daemon] EP1002: Running setup script`);
+      const scriptResult = await worktreeManager.runSetupScript(moduleUid, setupScript);
+      if (!scriptResult.success) {
+        throw new Error(`Setup script failed: ${scriptResult.error}`);
+      }
+    }
+    await worktreeManager.updateWorktreeStatus(moduleUid, "ready");
+    await this.updateModuleWorktreeStatus(moduleUid, "ready", worktreePath);
+    console.log(`[Daemon] EP1002: Worktree setup complete for ${moduleUid}`);
+  }
   /**
    * EP959-11: Run worktree setup asynchronously
    * EP964: Added envVars parameter to inject .env file