episoda 0.2.26 → 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 fs15 = 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 fs15.access(rebaseMergePath);
+              await fs16.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs15.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 fs15 = 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 fs15.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 fs15 = 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 fs15.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 fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path16 = 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 fs15.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 = path16.dirname(command.path);
+          const parentDir = path17.dirname(command.path);
           try {
-            await fs15.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 fs15 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path16 = 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 = path16.join(currentPath, ".bare");
-            const episodaDir = path16.join(currentPath, ".episoda");
+            const bareDir = path17.join(currentPath, ".bare");
+            const episodaDir = path17.join(currentPath, ".episoda");
             try {
-              await fs15.access(bareDir);
-              await fs15.access(episodaDir);
+              await fs16.access(bareDir);
+              await fs16.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path16.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 fs15 = __importStar(require("fs"));
-    var path16 = __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 || path16.join(os6.homedir(), ".episoda");
+      return process.env.EPISODA_CONFIG_DIR || path17.join(os6.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path16.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
+      return path17.join(getConfigDir6(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path16.dirname(configPath);
-      const isNew = !fs15.existsSync(dir);
+      const dir = path17.dirname(configPath);
+      const isNew = !fs16.existsSync(dir);
       if (isNew) {
-        fs15.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs16.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path16.join(dir, ".nosync");
-        if (isNew || !fs15.existsSync(nosyncPath)) {
+        const nosyncPath = path17.join(dir, ".nosync");
+        if (isNew || !fs16.existsSync(nosyncPath)) {
           try {
-            fs15.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 (!fs15.existsSync(fullPath)) {
+      if (!fs16.existsSync(fullPath)) {
         return null;
       }
       try {
-        const content = fs15.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);
-        fs15.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.25",
+      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
@@ -6103,61 +6122,61 @@ function clearAllPorts() {
 }
 
 // src/framework-detector.ts
-var fs13 = __toESM(require("fs"));
-var path14 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs13.existsSync(path14.join(cwd, "bun.lockb"))) {
+  if (fs14.existsSync(path15.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs14.existsSync(path15.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "yarn.lock"))) {
+  if (fs14.existsSync(path15.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "package-lock.json"))) {
+  if (fs14.existsSync(path15.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "package.json"))) {
+  if (fs14.existsSync(path15.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "Pipfile.lock")) || fs13.existsSync(path14.join(cwd, "Pipfile"))) {
+  if (fs14.existsSync(path15.join(cwd, "Pipfile.lock")) || fs14.existsSync(path15.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs13.existsSync(path14.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs14.existsSync(path15.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "poetry.lock"))) {
+  if (fs14.existsSync(path15.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path14.join(cwd, "pyproject.toml");
-    const content = fs13.readFileSync(pyprojectPath, "utf-8");
+  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"],
@@ -6166,41 +6185,41 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs13.existsSync(path14.join(cwd, "requirements.txt"))) {
+  if (fs14.existsSync(path15.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "Gemfile.lock")) || fs13.existsSync(path14.join(cwd, "Gemfile"))) {
+  if (fs14.existsSync(path15.join(cwd, "Gemfile.lock")) || fs14.existsSync(path15.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs13.existsSync(path14.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs14.existsSync(path15.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "go.sum")) || fs13.existsSync(path14.join(cwd, "go.mod"))) {
+  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: fs13.existsSync(path14.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs14.existsSync(path15.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs13.existsSync(path14.join(cwd, "Cargo.lock")) || fs13.existsSync(path14.join(cwd, "Cargo.toml"))) {
+  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: fs13.existsSync(path14.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs14.existsSync(path15.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs14 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var path15 = __toESM(require("path"));
+var path16 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -6697,7 +6716,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path15.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}`);
@@ -7307,8 +7326,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs14.existsSync(pidPath)) {
-          const pidStr = fs14.readFileSync(pidPath, "utf-8").trim();
+        if (fs15.existsSync(pidPath)) {
+          const pidStr = fs15.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -7429,27 +7448,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path15.join(projectPath, ".git", "hooks");
-    if (!fs14.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 = path15.join(hooksDir, hookName);
-        const bundledHookPath = path15.join(__dirname, "..", "hooks", hookName);
-        if (!fs14.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 = fs14.readFileSync(bundledHookPath, "utf-8");
-        if (fs14.existsSync(hookPath)) {
-          const existingContent = fs14.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;
           }
         }
-        fs14.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);
@@ -7569,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 = path15.join(worktreePath, ".env");
-        fs14.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}`);
@@ -8354,8 +8364,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs14.existsSync(pidPath)) {
-        fs14.unlinkSync(pidPath);
+      if (fs15.existsSync(pidPath)) {
+        fs15.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {