episoda 0.2.22 → 0.2.24

package/dist/daemon/daemon-process.js

@@ -537,6 +537,24 @@ var require_git_executor = __commonJS({
        * Execute status command
        */
       async executeStatus(cwd, options) {
+        try {
+          const isBareResult = await execAsync2("git rev-parse --is-bare-repository", { cwd, timeout: 5e3 });
+          if (isBareResult.stdout.trim() === "true") {
+            const headResult = await execAsync2("git symbolic-ref --short HEAD", { cwd, timeout: 5e3 });
+            const branchName = headResult.stdout.trim();
+            return {
+              success: true,
+              output: `## ${branchName}`,
+              details: {
+                uncommittedFiles: [],
+                // No working tree in bare repo
+                branchName,
+                currentBranch: branchName
+              }
+            };
+          }
+        } catch {
+        }
         const result = await this.runGitCommand(["status", "--porcelain", "-b"], cwd, options);
         if (result.success && result.output) {
           const statusInfo = (0, git_parser_1.parseGitStatus)(result.output);
@@ -1868,7 +1886,6 @@ var require_git_executor = __commonJS({
           const fs14 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           const path15 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
-          let worktreeMode = false;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
@@ -1877,7 +1894,6 @@ var require_git_executor = __commonJS({
             try {
               await fs14.access(bareDir);
               await fs14.access(episodaDir);
-              worktreeMode = true;
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
@@ -1891,9 +1907,8 @@ var require_git_executor = __commonJS({
           }
           return {
             success: true,
-            output: worktreeMode ? "Worktree mode project" : "Standard git project",
+            output: bareRepoPath ? "Episoda project" : "Git repository",
             details: {
-              worktreeMode,
               projectPath,
               bareRepoPath
             }
@@ -2681,7 +2696,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.21",
+      version: "0.2.23",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -2883,9 +2898,6 @@ function addProject(projectId, projectPath, options) {
   if (existingByPath) {
     existingByPath.id = projectId;
     existingByPath.last_active = now;
-    if (options?.worktreeMode !== void 0) {
-      existingByPath.worktreeMode = options.worktreeMode;
-    }
     if (options?.bareRepoPath) {
       existingByPath.bareRepoPath = options.bareRepoPath;
     }
@@ -2905,8 +2917,7 @@ function addProject(projectId, projectPath, options) {
     name: projectName,
     added_at: now,
     last_active: now,
-    // EP944: Worktree mode fields
-    worktreeMode: options?.worktreeMode,
+    // EP971: Bare repo path for worktree architecture
     bareRepoPath: options?.bareRepoPath
   };
   data.projects.push(newProject);
@@ -5447,7 +5458,8 @@ var WorktreeManager = class _WorktreeManager {
   }
   /**
    * Initialize worktree manager from existing project root
-   * @returns true if valid worktree project, false otherwise
+   * EP971: All projects use worktree architecture
+   * @returns true if valid project, false otherwise
    */
   async initialize() {
     if (!fs11.existsSync(this.bareRepoPath)) {
@@ -5458,7 +5470,7 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       const config = this.readConfig();
-      return config?.worktreeMode === true;
+      return config !== null;
     } catch {
       return false;
     }
@@ -5483,7 +5495,6 @@ var WorktreeManager = class _WorktreeManager {
       workspaceSlug,
       projectSlug,
       bareRepoPath: manager.bareRepoPath,
-      worktreeMode: true,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
       worktrees: []
     };
@@ -6163,6 +6174,28 @@ async function fetchWithAuth(url, options = {}, retryOnUnauthorized = true) {
   }
   return response;
 }
+async function fetchEnvVars() {
+  try {
+    const config = await (0, import_core10.loadConfig)();
+    if (!config?.project_id) {
+      console.warn("[Daemon] EP973: No project_id in config, cannot fetch env vars");
+      return {};
+    }
+    const apiUrl = config.api_url || "https://episoda.dev";
+    const response = await fetchWithAuth(`${apiUrl}/api/cli/env-vars`);
+    if (!response.ok) {
+      console.warn(`[Daemon] EP973: Failed to fetch env vars: ${response.status}`);
+      return {};
+    }
+    const data = await response.json();
+    const envVars = data.env_vars || {};
+    console.log(`[Daemon] EP973: Fetched ${Object.keys(envVars).length} env vars from server`);
+    return envVars;
+  } catch (error) {
+    console.warn("[Daemon] EP973: Error fetching env vars:", error instanceof Error ? error.message : error);
+    return {};
+  }
+}
 var Daemon = class _Daemon {
   // 60 seconds
   constructor() {
@@ -6569,9 +6602,12 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const cwd = gitCmd.worktreePath || projectPath;
+          const bareRepoPath = path14.join(projectPath, ".bare");
+          const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
-            console.log(`[Daemon] EP944: Routing command to worktree: ${gitCmd.worktreePath}`);
+            console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
+          } else {
+            console.log(`[Daemon] Running git command in bare repo: ${bareRepoPath}`);
           }
           const result = await gitExecutor.execute(gitCmd, {
             cwd
@@ -6674,7 +6710,27 @@ var Daemon = class _Daemon {
           const tunnelManager = getTunnelManager();
           let result;
           if (cmd.action === "start") {
-            const port = cmd.port || detectDevPort(projectPath);
+            const worktree = await getWorktreeInfoForModule(cmd.moduleUid);
+            if (!worktree) {
+              console.error(`[Daemon] EP973: Cannot resolve worktree path for ${cmd.moduleUid}`);
+              await client.send({
+                type: "tunnel_result",
+                commandId: message.id,
+                result: { success: false, error: "Cannot resolve worktree path - missing config slugs" }
+              });
+              return;
+            }
+            if (!worktree.exists) {
+              console.error(`[Daemon] EP973: Worktree not found at ${worktree.path}`);
+              await client.send({
+                type: "tunnel_result",
+                commandId: message.id,
+                result: { success: false, error: `Worktree not found at ${worktree.path}` }
+              });
+              return;
+            }
+            console.log(`[Daemon] EP973: Using worktree path ${worktree.path} for ${cmd.moduleUid}`);
+            const port = cmd.port || detectDevPort(worktree.path);
             const previewUrl = `https://${cmd.moduleUid.toLowerCase()}-${cmd.projectUid.toLowerCase()}.episoda.site`;
             const reportTunnelStatus = async (data) => {
               const config2 = await (0, import_core10.loadConfig)();
@@ -6709,8 +6765,10 @@ var Daemon = class _Daemon {
               });
               try {
                 await tunnelManager.initialize();
-                console.log(`[Daemon] Ensuring dev server is running on port ${port}...`);
-                const devServerResult = await ensureDevServer(projectPath, port, cmd.moduleUid);
+                const devConfig = await (0, import_core10.loadConfig)();
+                const devServerScript = devConfig?.project_settings?.worktree_dev_server_script;
+                console.log(`[Daemon] EP973: Ensuring dev server is running in ${worktree.path} on port ${port}...`);
+                const devServerResult = await ensureDevServer(worktree.path, port, cmd.moduleUid, devServerScript);
                 if (!devServerResult.success) {
                   const errorMsg2 = `Dev server failed to start: ${devServerResult.error}`;
                   console.error(`[Daemon] ${errorMsg2}`);
@@ -7041,17 +7099,18 @@ var Daemon = class _Daemon {
                 }
                 const worktreeConfig = await (0, import_core10.loadConfig)();
                 const setupConfig = worktreeConfig?.project_settings;
-                const hasEnvVars = setupConfig?.worktree_env_vars && Object.keys(setupConfig.worktree_env_vars).length > 0;
+                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}`);
                   await worktreeManager.updateWorktreeStatus(moduleUid, "pending");
                   this.runWorktreeSetupAsync(
                     moduleUid,
                     worktreeManager,
-                    setupConfig.worktree_copy_files || [],
-                    setupConfig.worktree_setup_script,
+                    setupConfig?.worktree_copy_files || [],
+                    setupConfig?.worktree_setup_script,
                     worktree.path,
-                    setupConfig.worktree_env_vars || {}
+                    envVars
                   ).then(() => {
                     console.log(`[Daemon] EP959: Setup complete for ${moduleUid}, starting tunnel`);
                     this.startTunnelForModule(moduleUid, worktree.path);
@@ -7345,22 +7404,31 @@ var Daemon = class _Daemon {
       const data = await response.json();
       const serverSettings = data.settings;
       if (serverSettings) {
-        const envVars = serverSettings.worktree_env_vars || {};
+        const projectSlug = data.project_slug || config.project_slug;
+        const workspaceSlug = data.workspace_slug || config.workspace_slug;
+        if (data.project_slug && !config.project_slug) {
+          console.log(`[Daemon] EP973: Synced project_slug: ${data.project_slug}`);
+        }
+        if (data.workspace_slug && !config.workspace_slug) {
+          console.log(`[Daemon] EP973: Synced workspace_slug: ${data.workspace_slug}`);
+        }
         const updatedConfig = {
           ...config,
+          // EP973: Include synced slugs
+          project_slug: projectSlug,
+          workspace_slug: workspaceSlug,
           project_settings: {
             ...config.project_settings,
             worktree_setup_script: serverSettings.worktree_setup_script,
             worktree_cleanup_script: serverSettings.worktree_cleanup_script,
             worktree_dev_server_script: serverSettings.worktree_dev_server_script,
-            worktree_env_vars: envVars,
             // Keep deprecated field for backward compatibility
             worktree_copy_files: serverSettings.worktree_copy_files,
             cached_at: Date.now()
           }
         };
         await (0, import_core10.saveConfig)(updatedConfig);
-        console.log(`[Daemon] EP964: Project settings synced (env_vars: ${Object.keys(envVars).length} keys)`);
+        console.log(`[Daemon] EP973: Project settings synced (slugs: ${projectSlug}/${workspaceSlug})`);
       }
     } catch (error) {
       console.warn("[Daemon] EP964: Failed to sync project settings:", error instanceof Error ? error.message : error);
@@ -7937,14 +8005,13 @@ var Daemon = class _Daemon {
         } catch (e) {
           console.warn(`[Daemon] EP833: Failed to fetch module details for project lookup`);
         }
-        const trackedProjects = getAllProjects();
-        let project = projectId ? trackedProjects.find((p) => p.id === projectId) : trackedProjects[0];
-        if (!project && trackedProjects.length > 0) {
-          project = trackedProjects[0];
-          console.warn(`[Daemon] EP833: Could not find project ${projectId}, using fallback`);
+        const worktree = await getWorktreeInfoForModule(moduleUid);
+        if (!worktree) {
+          console.error(`[Daemon] EP973: Cannot resolve worktree path for ${moduleUid} - missing config slugs`);
+          return;
         }
-        if (!project) {
-          console.error(`[Daemon] EP833: No project found for tunnel restart`);
+        if (!worktree.exists) {
+          console.error(`[Daemon] EP973: Worktree not found at ${worktree.path}`);
           return;
         }
         const { isPortInUse: isPortInUse2 } = await Promise.resolve().then(() => (init_port_check(), port_check_exports));
@@ -7956,7 +8023,8 @@ var Daemon = class _Daemon {
             await killProcessOnPort(port);
           }
         }
-        const startResult2 = await ensureDevServer(project.path, port, moduleUid);
+        const devServerScript = config.project_settings?.worktree_dev_server_script;
+        const startResult2 = await ensureDevServer(worktree.path, port, moduleUid, devServerScript);
         if (!startResult2.success) {
           console.error(`[Daemon] EP932: Failed to start dev server: ${startResult2.error}`);
           return;