episoda 0.2.23 → 0.2.24

package/dist/daemon/daemon-process.js

@@ -2696,7 +2696,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.22",
+      version: "0.2.23",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -6174,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() {
@@ -6688,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)();
@@ -6723,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}`);
@@ -7055,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);
@@ -7359,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);
@@ -7951,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));
@@ -7970,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;