episoda 0.2.25 → 0.2.27

package/dist/daemon/daemon-process.js

@@ -1556,15 +1556,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync2("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs14.access(rebaseMergePath);
+              await fs16.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs14.access(rebaseApplyPath);
+                await fs16.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1618,9 +1618,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs14.access(command.path);
+            await fs16.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1671,9 +1671,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs14.access(command.path);
+            await fs16.access(command.path);
           } catch {
             return {
               success: false,
@@ -1826,10 +1826,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path17 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs14.access(command.path);
+            await fs16.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1838,9 +1838,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path15.dirname(command.path);
+          const parentDir = path17.dirname(command.path);
           try {
-            await fs14.mkdir(parentDir, { recursive: true });
+            await fs16.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync2(
@@ -1883,22 +1883,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path15 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs16 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path17 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path15.join(currentPath, ".bare");
-            const episodaDir = path15.join(currentPath, ".episoda");
+            const bareDir = path17.join(currentPath, ".bare");
+            const episodaDir = path17.join(currentPath, ".episoda");
             try {
-              await fs14.access(bareDir);
-              await fs14.access(episodaDir);
+              await fs16.access(bareDir);
+              await fs16.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path15.dirname(currentPath);
+              const parentPath = path17.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2492,31 +2492,31 @@ var require_auth = __commonJS({
     exports2.loadConfig = loadConfig5;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs14 = __importStar(require("fs"));
-    var path15 = __importStar(require("path"));
+    var fs16 = __importStar(require("fs"));
+    var path17 = __importStar(require("path"));
     var os6 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
     function getConfigDir6() {
-      return process.env.EPISODA_CONFIG_DIR || path15.join(os6.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path17.join(os6.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path15.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
+      return path17.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path15.dirname(configPath);
-      const isNew = !fs14.existsSync(dir);
+      const dir = path17.dirname(configPath);
+      const isNew = !fs16.existsSync(dir);
       if (isNew) {
-        fs14.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs16.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path15.join(dir, ".nosync");
-        if (isNew || !fs14.existsSync(nosyncPath)) {
+        const nosyncPath = path17.join(dir, ".nosync");
+        if (isNew || !fs16.existsSync(nosyncPath)) {
           try {
-            fs14.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs16.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2528,11 +2528,11 @@ var require_auth = __commonJS({
     }
     async function loadConfig5(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (!fs14.existsSync(fullPath)) {
+      if (!fs16.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs14.readFileSync(fullPath, "utf8");
+        const content = fs16.readFileSync(fullPath, "utf8");
         const config = JSON.parse(content);
         return config;
       } catch (error) {
@@ -2545,7 +2545,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs14.writeFileSync(fullPath, content, { mode: 384 });
+        fs16.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2696,7 +2696,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.24",
+      version: "0.2.26",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -6023,20 +6023,39 @@ async function findProjectRoot(startPath) {
   return null;
 }
 
-// src/utils/worktree.ts
-var path13 = __toESM(require("path"));
+// src/utils/env-setup.ts
 var fs12 = __toESM(require("fs"));
+var path13 = __toESM(require("path"));
+function writeEnvFile(targetPath, envVars) {
+  if (Object.keys(envVars).length === 0) {
+    return;
+  }
+  const envContent = Object.entries(envVars).map(([key, value]) => {
+    if (/[\s'"#$`\\]/.test(value) || value.includes("\n")) {
+      const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+      return `${key}="${escaped}"`;
+    }
+    return `${key}=${value}`;
+  }).join("\n") + "\n";
+  const envPath = path13.join(targetPath, ".env");
+  fs12.writeFileSync(envPath, envContent, { mode: 384 });
+  console.log(`[env-setup] Wrote ${Object.keys(envVars).length} env vars to ${envPath}`);
+}
+
+// src/utils/worktree.ts
+var path14 = __toESM(require("path"));
+var fs13 = __toESM(require("fs"));
 var os4 = __toESM(require("os"));
 var import_core9 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path13.join(os4.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path14.join(os4.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path13.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path14.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs12.existsSync(worktreePath),
+    exists: fs13.existsSync(worktreePath),
     moduleUid
   };
 }
@@ -6053,7 +6072,7 @@ async function getProjectRootPath() {
   if (!config?.workspace_slug || !config?.project_slug) {
     return null;
   }
-  return path13.join(
+  return path14.join(
     getEpisodaRoot2(),
     config.workspace_slug,
     config.project_slug
@@ -6102,10 +6121,105 @@ function clearAllPorts() {
   }
 }
 
+// src/framework-detector.ts
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+function getInstallCommand(cwd) {
+  if (fs14.existsSync(path15.join(cwd, "bun.lockb"))) {
+    return {
+      command: ["bun", "install"],
+      description: "Installing dependencies with bun",
+      detectedFrom: "bun.lockb"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "pnpm-lock.yaml"))) {
+    return {
+      command: ["pnpm", "install"],
+      description: "Installing dependencies with pnpm",
+      detectedFrom: "pnpm-lock.yaml"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "yarn.lock"))) {
+    return {
+      command: ["yarn", "install"],
+      description: "Installing dependencies with yarn",
+      detectedFrom: "yarn.lock"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "package-lock.json"))) {
+    return {
+      command: ["npm", "ci"],
+      description: "Installing dependencies with npm ci",
+      detectedFrom: "package-lock.json"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "package.json"))) {
+    return {
+      command: ["npm", "install"],
+      description: "Installing dependencies with npm",
+      detectedFrom: "package.json"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "Pipfile.lock")) || fs14.existsSync(path15.join(cwd, "Pipfile"))) {
+    return {
+      command: ["pipenv", "install"],
+      description: "Installing dependencies with pipenv",
+      detectedFrom: fs14.existsSync(path15.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "poetry.lock"))) {
+    return {
+      command: ["poetry", "install"],
+      description: "Installing dependencies with poetry",
+      detectedFrom: "poetry.lock"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path15.join(cwd, "pyproject.toml");
+    const content = fs14.readFileSync(pyprojectPath, "utf-8");
+    if (content.includes("[tool.poetry]")) {
+      return {
+        command: ["poetry", "install"],
+        description: "Installing dependencies with poetry",
+        detectedFrom: "pyproject.toml"
+      };
+    }
+  }
+  if (fs14.existsSync(path15.join(cwd, "requirements.txt"))) {
+    return {
+      command: ["pip", "install", "-r", "requirements.txt"],
+      description: "Installing dependencies with pip",
+      detectedFrom: "requirements.txt"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "Gemfile.lock")) || fs14.existsSync(path15.join(cwd, "Gemfile"))) {
+    return {
+      command: ["bundle", "install"],
+      description: "Installing dependencies with bundler",
+      detectedFrom: fs14.existsSync(path15.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "go.sum")) || fs14.existsSync(path15.join(cwd, "go.mod"))) {
+    return {
+      command: ["go", "mod", "download"],
+      description: "Downloading Go modules",
+      detectedFrom: fs14.existsSync(path15.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+    };
+  }
+  if (fs14.existsSync(path15.join(cwd, "Cargo.lock")) || fs14.existsSync(path15.join(cwd, "Cargo.toml"))) {
+    return {
+      command: ["cargo", "build"],
+      description: "Building Rust project (downloads dependencies)",
+      detectedFrom: fs14.existsSync(path15.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+    };
+  }
+  return null;
+}
+
 // src/daemon/daemon-process.ts
-var fs13 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path14 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -6602,7 +6716,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path14.join(projectPath, ".bare");
+          const bareRepoPath = path16.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -7101,8 +7215,9 @@ var Daemon = class _Daemon {
                 const setupConfig = worktreeConfig?.project_settings;
                 const envVars = await fetchEnvVars();
                 const hasEnvVars = Object.keys(envVars).length > 0;
-                if (setupConfig?.worktree_copy_files?.length || setupConfig?.worktree_setup_script || hasEnvVars) {
-                  console.log(`[Daemon] EP959: Starting async worktree setup for ${moduleUid}`);
+                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");
                   this.runWorktreeSetupAsync(
                     moduleUid,
@@ -7111,6 +7226,7 @@ var Daemon = class _Daemon {
                     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);
@@ -7119,7 +7235,8 @@ var Daemon = class _Daemon {
                   });
                   return;
                 }
-              } else if (!worktree.exists) {
+              }
+              if (!worktree.exists) {
                 console.log(`[Daemon] EP956: No worktree for ${moduleUid} at ${worktree.path}, skipping tunnel`);
                 return;
               }
@@ -7209,8 +7326,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs13.existsSync(pidPath)) {
-          const pidStr = fs13.readFileSync(pidPath, "utf-8").trim();
+        if (fs15.existsSync(pidPath)) {
+          const pidStr = fs15.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -7331,27 +7448,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path14.join(projectPath, ".git", "hooks");
-    if (!fs13.existsSync(hooksDir)) {
+    const hooksDir = path16.join(projectPath, ".git", "hooks");
+    if (!fs15.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path14.join(hooksDir, hookName);
-        const bundledHookPath = path14.join(__dirname, "..", "hooks", hookName);
-        if (!fs13.existsSync(bundledHookPath)) {
+        const hookPath = path16.join(hooksDir, hookName);
+        const bundledHookPath = path16.join(__dirname, "..", "hooks", hookName);
+        if (!fs15.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs13.readFileSync(bundledHookPath, "utf-8");
-        if (fs13.existsSync(hookPath)) {
-          const existingContent = fs13.readFileSync(hookPath, "utf-8");
+        const hookContent = fs15.readFileSync(bundledHookPath, "utf-8");
+        if (fs15.existsSync(hookPath)) {
+          const existingContent = fs15.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs13.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs15.writeFileSync(hookPath, hookContent, { mode: 493 });
         console.log(`[Daemon] Installed git hook: ${hookName}`);
       } catch (error) {
         console.warn(`[Daemon] Failed to install ${hookName} hook:`, error instanceof Error ? error.message : error);
@@ -7471,17 +7588,8 @@ var Daemon = class _Daemon {
     try {
       await worktreeManager.updateWorktreeStatus(moduleUid, "running");
       if (Object.keys(envVars).length > 0) {
-        console.log(`[Daemon] EP964: Writing .env with ${Object.keys(envVars).length} variables to ${moduleUid}`);
-        const envContent = Object.entries(envVars).map(([key, value]) => {
-          if (/[\s'"#$`\\]/.test(value) || value.includes("\n")) {
-            const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
-            return `${key}="${escaped}"`;
-          }
-          return `${key}=${value}`;
-        }).join("\n") + "\n";
-        const envPath = path14.join(worktreePath, ".env");
-        fs13.writeFileSync(envPath, envContent, { mode: 384 });
-        console.log(`[Daemon] EP964: .env written to ${envPath}`);
+        console.log(`[Daemon] EP988: Writing .env with ${Object.keys(envVars).length} variables to ${moduleUid}`);
+        writeEnvFile(worktreePath, envVars);
       }
       if (copyFiles.length > 0) {
         console.log(`[Daemon] EP964: DEPRECATED - Copying ${copyFiles.length} files to ${moduleUid}`);
@@ -7491,6 +7599,29 @@ var Daemon = class _Daemon {
           console.warn(`[Daemon] EP964: File copy failed (non-fatal): ${copyResult.error}`);
         }
       }
+      const installCmd = getInstallCommand(worktreePath);
+      if (installCmd) {
+        console.log(`[Daemon] EP986: ${installCmd.description} (detected from ${installCmd.detectedFrom})`);
+        console.log(`[Daemon] EP986: Running: ${installCmd.command.join(" ")}`);
+        try {
+          const { execSync: execSync6 } = await import("child_process");
+          execSync6(installCmd.command.join(" "), {
+            cwd: worktreePath,
+            stdio: "inherit",
+            timeout: 10 * 60 * 1e3,
+            // 10 minute timeout
+            env: { ...process.env, CI: "true" }
+            // CI=true for cleaner output
+          });
+          console.log(`[Daemon] EP986: Dependencies installed successfully for ${moduleUid}`);
+        } catch (installError) {
+          const errorMsg = installError instanceof Error ? installError.message : String(installError);
+          console.warn(`[Daemon] EP986: Dependency installation failed (non-fatal): ${errorMsg}`);
+          console.warn(`[Daemon] EP986: You may need to run '${installCmd.command.join(" ")}' manually`);
+        }
+      } else {
+        console.log(`[Daemon] EP986: No package manager detected for ${moduleUid}, skipping dependency installation`);
+      }
       if (setupScript) {
         console.log(`[Daemon] EP959: Running setup script for ${moduleUid}`);
         const scriptResult = await worktreeManager.runSetupScript(moduleUid, setupScript);
@@ -8233,8 +8364,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs13.existsSync(pidPath)) {
-        fs13.unlinkSync(pidPath);
+      if (fs15.existsSync(pidPath)) {
+        fs15.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {