episoda 0.2.20 → 0.2.22

package/dist/daemon/daemon-process.js

@@ -2681,7 +2681,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.19",
+      version: "0.2.21",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -5141,12 +5141,15 @@ function calculateRestartDelay(restartCount) {
   const delay = INITIAL_RESTART_DELAY_MS * Math.pow(2, restartCount);
   return Math.min(delay, MAX_RESTART_DELAY_MS);
 }
-function spawnDevServerProcess(projectPath, port, moduleUid, logPath) {
+function spawnDevServerProcess(projectPath, port, moduleUid, logPath, customCommand) {
   rotateLogIfNeeded(logPath);
   const nodeOptions = process.env.NODE_OPTIONS || "";
   const memoryFlag = `--max-old-space-size=${NODE_MEMORY_LIMIT_MB}`;
   const enhancedNodeOptions = nodeOptions.includes("max-old-space-size") ? nodeOptions : `${nodeOptions} ${memoryFlag}`.trim();
-  const devProcess = (0, import_child_process9.spawn)("npm", ["run", "dev"], {
+  const command = customCommand || "npm run dev";
+  const [cmd, ...args] = command.split(" ");
+  console.log(`[DevServer] EP959: Starting with command: ${command}`);
+  const devProcess = (0, import_child_process9.spawn)(cmd, args, {
     cwd: projectPath,
     env: {
       ...process.env,
@@ -5154,7 +5157,9 @@ function spawnDevServerProcess(projectPath, port, moduleUid, logPath) {
       NODE_OPTIONS: enhancedNodeOptions
     },
     stdio: ["ignore", "pipe", "pipe"],
-    detached: false
+    detached: false,
+    shell: true
+    // EP959: Use shell to handle complex commands
   });
   devProcess.stdout?.on("data", (data) => {
     const line = data.toString().trim();
@@ -5200,7 +5205,7 @@ async function handleProcessExit(moduleUid, code, signal) {
     return;
   }
   const logPath = serverInfo.logFile || getLogFilePath(moduleUid);
-  const newProcess = spawnDevServerProcess(serverInfo.projectPath, serverInfo.port, moduleUid, logPath);
+  const newProcess = spawnDevServerProcess(serverInfo.projectPath, serverInfo.port, moduleUid, logPath, serverInfo.customCommand);
   const updatedInfo = {
     ...serverInfo,
     process: newProcess,
@@ -5227,6 +5232,7 @@ async function handleProcessExit(moduleUid, code, signal) {
 }
 async function startDevServer(projectPath, port = 3e3, moduleUid = "default", options = {}) {
   const autoRestart = options.autoRestart ?? true;
+  const customCommand = options.customCommand;
   if (await isPortInUse(port)) {
     console.log(`[DevServer] Server already running on port ${port}`);
     return { success: true, alreadyRunning: true };
@@ -5241,7 +5247,7 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
   console.log(`[DevServer] EP932: Starting dev server for ${moduleUid} on port ${port} (auto-restart: ${autoRestart})...`);
   try {
     const logPath = getLogFilePath(moduleUid);
-    const devProcess = spawnDevServerProcess(projectPath, port, moduleUid, logPath);
+    const devProcess = spawnDevServerProcess(projectPath, port, moduleUid, logPath, customCommand);
     const serverInfo = {
       process: devProcess,
       moduleUid,
@@ -5251,7 +5257,9 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
       restartCount: 0,
       lastRestartAt: null,
       autoRestartEnabled: autoRestart,
-      logFile: logPath
+      logFile: logPath,
+      customCommand
+      // EP959-m2: Store for restarts
     };
     activeServers.set(moduleUid, serverInfo);
     writeToLog(logPath, `Starting dev server on port ${port}`, false);
@@ -5329,11 +5337,11 @@ function getDevServerStatus() {
     logFile: info.logFile
   }));
 }
-async function ensureDevServer(projectPath, port = 3e3, moduleUid = "default") {
+async function ensureDevServer(projectPath, port = 3e3, moduleUid = "default", customCommand) {
   if (await isPortInUse(port)) {
     return { success: true };
   }
-  return startDevServer(projectPath, port, moduleUid, { autoRestart: true });
+  return startDevServer(projectPath, port, moduleUid, { autoRestart: true, customCommand });
 }
 
 // src/utils/port-detect.ts
@@ -5831,6 +5839,148 @@ var WorktreeManager = class _WorktreeManager {
       this.releaseLock();
     }
   }
+  // EP959-11: Worktree setup methods
+  /**
+   * Update the setup status of a worktree
+   */
+  async updateWorktreeStatus(moduleUid, status, error) {
+    return this.updateConfigSafe((config) => {
+      const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+      if (worktree) {
+        worktree.setupStatus = status;
+        if (status === "running") {
+          worktree.setupStartedAt = (/* @__PURE__ */ new Date()).toISOString();
+        } else if (status === "ready" || status === "error") {
+          worktree.setupCompletedAt = (/* @__PURE__ */ new Date()).toISOString();
+        }
+        if (error) {
+          worktree.setupError = error;
+        }
+      }
+      return config;
+    });
+  }
+  /**
+   * Get worktree info including setup status
+   */
+  getWorktreeStatus(moduleUid) {
+    const config = this.readConfig();
+    if (!config) return null;
+    return config.worktrees.find((w) => w.moduleUid === moduleUid) || null;
+  }
+  /**
+   * Copy files from main worktree to module worktree
+   *
+   * @deprecated EP964: This function is deprecated. Use worktree_env_vars for
+   * environment variables or worktree_setup_script for other file operations.
+   * This function now returns success (no-op) when main/ worktree doesn't exist.
+   */
+  async copyFilesFromMain(moduleUid, files) {
+    console.warn(`[WorktreeManager] EP964: copyFilesFromMain is DEPRECATED.`);
+    console.warn(`[WorktreeManager] EP964: Use worktree_env_vars for .env or worktree_setup_script for other files.`);
+    const config = this.readConfig();
+    if (!config) {
+      return { success: false, error: "Config not found" };
+    }
+    const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+    if (!worktree) {
+      return { success: false, error: `Worktree not found for ${moduleUid}` };
+    }
+    const mainWorktree = config.worktrees.find((w) => w.moduleUid === "main");
+    if (!mainWorktree) {
+      console.warn(`[WorktreeManager] EP964: No 'main' worktree - skipping file copy (this is expected).`);
+      return { success: true };
+    }
+    try {
+      for (const file of files) {
+        const srcPath = path12.join(mainWorktree.worktreePath, file);
+        const destPath = path12.join(worktree.worktreePath, file);
+        if (fs11.existsSync(srcPath)) {
+          const destDir = path12.dirname(destPath);
+          if (!fs11.existsSync(destDir)) {
+            fs11.mkdirSync(destDir, { recursive: true });
+          }
+          fs11.copyFileSync(srcPath, destPath);
+          console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
+        } else {
+          console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
+        }
+      }
+      return { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  /**
+   * Run worktree setup script
+   * EP959-M1: Enhanced logging with working directory, timeout info, and script preview
+   */
+  async runSetupScript(moduleUid, script) {
+    const config = this.readConfig();
+    if (!config) {
+      return { success: false, error: "Config not found" };
+    }
+    const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+    if (!worktree) {
+      return { success: false, error: `Worktree not found for ${moduleUid}` };
+    }
+    const TIMEOUT_MINUTES = 10;
+    const scriptPreview = script.length > 200 ? script.slice(0, 200) + "..." : script;
+    console.log(`[WorktreeManager] EP959: Running setup script for ${moduleUid}`);
+    console.log(`[WorktreeManager] EP959:   Working directory: ${worktree.worktreePath}`);
+    console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
+    console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
+    try {
+      const { execSync: execSync6 } = require("child_process");
+      execSync6(script, {
+        cwd: worktree.worktreePath,
+        stdio: "inherit",
+        timeout: TIMEOUT_MINUTES * 60 * 1e3,
+        env: { ...process.env, NODE_ENV: "development" }
+      });
+      console.log(`[WorktreeManager] EP959: Setup script completed successfully for ${moduleUid}`);
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[WorktreeManager] EP959: Setup script failed for ${moduleUid}:`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  }
+  /**
+   * Run worktree cleanup script before removal
+   * EP959-m3: Execute cleanup script when worktree is being released
+   */
+  async runCleanupScript(moduleUid, script) {
+    const config = this.readConfig();
+    if (!config) {
+      return { success: false, error: "Config not found" };
+    }
+    const worktree = config.worktrees.find((w) => w.moduleUid === moduleUid);
+    if (!worktree) {
+      return { success: false, error: `Worktree not found for ${moduleUid}` };
+    }
+    const TIMEOUT_MINUTES = 5;
+    const scriptPreview = script.length > 200 ? script.slice(0, 200) + "..." : script;
+    console.log(`[WorktreeManager] EP959: Running cleanup script for ${moduleUid}`);
+    console.log(`[WorktreeManager] EP959:   Working directory: ${worktree.worktreePath}`);
+    console.log(`[WorktreeManager] EP959:   Timeout: ${TIMEOUT_MINUTES} minutes`);
+    console.log(`[WorktreeManager] EP959:   Script: ${scriptPreview}`);
+    try {
+      const { execSync: execSync6 } = require("child_process");
+      execSync6(script, {
+        cwd: worktree.worktreePath,
+        stdio: "inherit",
+        timeout: TIMEOUT_MINUTES * 60 * 1e3,
+        env: { ...process.env, NODE_ENV: "development" }
+      });
+      console.log(`[WorktreeManager] EP959: Cleanup script completed successfully for ${moduleUid}`);
+      return { success: true };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.warn(`[WorktreeManager] EP959: Cleanup script failed for ${moduleUid} (non-blocking):`, errorMessage);
+      return { success: false, error: errorMessage };
+    }
+  }
 };
 function getEpisodaRoot() {
   return process.env.EPISODA_ROOT || path12.join(require("os").homedir(), "episoda");
@@ -5887,6 +6037,17 @@ 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 path13.join(
+    getEpisodaRoot2(),
+    config.workspace_slug,
+    config.project_slug
+  );
+}
 
 // src/utils/port-allocator.ts
 var PORT_RANGE_START = 3100;
@@ -6694,11 +6855,19 @@ var Daemon = class _Daemon {
           let result;
           if (cmd.action === "start") {
             const callbacks = createStreamingCallbacks(cmd.sessionId, message.id);
+            let agentWorkingDir = projectPath;
+            if (cmd.moduleUid) {
+              const worktreeInfo = await getWorktreeInfoForModule(cmd.moduleUid);
+              if (worktreeInfo?.exists) {
+                agentWorkingDir = worktreeInfo.path;
+                console.log(`[Daemon] EP959: Agent for ${cmd.moduleUid} in worktree: ${agentWorkingDir}`);
+              }
+            }
             const startResult = await agentManager.startSession({
               sessionId: cmd.sessionId,
               moduleId: cmd.moduleId,
               moduleUid: cmd.moduleUid,
-              projectPath,
+              projectPath: agentWorkingDir,
               message: cmd.message,
               credentials: cmd.credentials,
               systemPrompt: cmd.systemPrompt,
@@ -6799,6 +6968,9 @@ var Daemon = class _Daemon {
         this.flyMachineId = authMessage.flyMachineId;
         console.log(`[Daemon] Fly Machine ID: ${this.flyMachineId}`);
       }
+      this.syncProjectSettings(projectId).catch((err) => {
+        console.warn("[Daemon] EP964: Settings sync failed:", err.message);
+      });
       this.autoStartTunnelsForProject(projectPath, projectId).catch((error) => {
         console.error(`[Daemon] EP819: Failed to auto-start tunnels:`, error);
       });
@@ -6837,24 +7009,72 @@ var Daemon = class _Daemon {
             }
             console.log(`[Daemon] EP956: Starting tunnel for ${moduleUid} (${previousState} \u2192 ${state})`);
             try {
-              const worktree = await getWorktreeInfoForModule(moduleUid);
+              let worktree = await getWorktreeInfoForModule(moduleUid);
               if (!worktree) {
                 console.error(`[Daemon] EP956: Cannot resolve worktree path for ${moduleUid} (missing config slugs)`);
                 return;
               }
-              if (!worktree.exists) {
+              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}`);
+                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 hasEnvVars = setupConfig?.worktree_env_vars && Object.keys(setupConfig.worktree_env_vars).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,
+                    worktree.path,
+                    setupConfig.worktree_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;
+                }
+              } else if (!worktree.exists) {
                 console.log(`[Daemon] EP956: No worktree for ${moduleUid} at ${worktree.path}, skipping tunnel`);
                 return;
               }
               const port = allocatePort(moduleUid);
               console.log(`[Daemon] EP956: Using worktree ${worktree.path} on port ${port}`);
-              const devServerResult = await ensureDevServer(worktree.path, port, moduleUid);
+              const devConfig = await (0, import_core10.loadConfig)();
+              const devServerScript = devConfig?.project_settings?.worktree_dev_server_script;
+              const devServerResult = await ensureDevServer(worktree.path, port, moduleUid, devServerScript);
               if (!devServerResult.success) {
                 console.error(`[Daemon] EP956: Dev server failed for ${moduleUid}: ${devServerResult.error}`);
                 releasePort(moduleUid);
                 return;
               }
-              const config2 = await (0, import_core10.loadConfig)();
+              const config2 = devConfig;
               const apiUrl = config2?.api_url || "https://episoda.dev";
               const startResult = await tunnelManager.startTunnel({
                 moduleUid,
@@ -7106,6 +7326,46 @@ var Daemon = class _Daemon {
       console.warn("[Daemon] Failed to cache device ID:", error instanceof Error ? error.message : error);
     }
   }
+  /**
+   * EP964: Sync project settings from server on connect/reconnect
+   *
+   * Fetches worktree_env_vars and other settings from the server
+   * and caches them locally for use during worktree checkout.
+   */
+  async syncProjectSettings(projectId) {
+    try {
+      const config = await (0, import_core10.loadConfig)();
+      if (!config) return;
+      const apiUrl = config.api_url || "https://episoda.dev";
+      const response = await fetchWithAuth(`${apiUrl}/api/projects/${projectId}/settings`);
+      if (!response.ok) {
+        console.warn(`[Daemon] EP964: Failed to sync settings: ${response.status}`);
+        return;
+      }
+      const data = await response.json();
+      const serverSettings = data.settings;
+      if (serverSettings) {
+        const envVars = serverSettings.worktree_env_vars || {};
+        const updatedConfig = {
+          ...config,
+          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)`);
+      }
+    } catch (error) {
+      console.warn("[Daemon] EP964: Failed to sync project settings:", error instanceof Error ? error.message : error);
+    }
+  }
   /**
    * EP956: Cleanup module worktree when module moves to done
    *
@@ -7133,6 +7393,105 @@ var Daemon = class _Daemon {
       throw error;
     }
   }
+  /**
+   * EP959-11: Run worktree setup asynchronously
+   * EP964: Added envVars parameter to inject .env file
+   * Writes .env, copies files, and runs setup script after worktree creation
+   */
+  async runWorktreeSetupAsync(moduleUid, worktreeManager, copyFiles, setupScript, worktreePath, envVars = {}) {
+    console.log(`[Daemon] EP959: Running async worktree setup for ${moduleUid}`);
+    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}`);
+      }
+      if (copyFiles.length > 0) {
+        console.log(`[Daemon] EP964: DEPRECATED - Copying ${copyFiles.length} files to ${moduleUid}`);
+        console.warn(`[Daemon] EP964: worktree_copy_files is deprecated. Use worktree_env_vars or worktree_setup_script instead.`);
+        const copyResult = await worktreeManager.copyFilesFromMain(moduleUid, copyFiles);
+        if (!copyResult.success) {
+          console.warn(`[Daemon] EP964: File copy failed (non-fatal): ${copyResult.error}`);
+        }
+      }
+      if (setupScript) {
+        console.log(`[Daemon] EP959: Running setup script for ${moduleUid}`);
+        const scriptResult = await worktreeManager.runSetupScript(moduleUid, setupScript);
+        if (!scriptResult.success) {
+          throw new Error(`Setup script failed: ${scriptResult.error}`);
+        }
+      }
+      await worktreeManager.updateWorktreeStatus(moduleUid, "ready");
+      console.log(`[Daemon] EP959: Worktree setup complete for ${moduleUid}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error(`[Daemon] EP959: Worktree setup failed for ${moduleUid}:`, errorMessage);
+      await worktreeManager.updateWorktreeStatus(moduleUid, "error", errorMessage);
+      throw error;
+    }
+  }
+  /**
+   * EP959-11: Start tunnel for a module after setup completes
+   */
+  async startTunnelForModule(moduleUid, worktreePath) {
+    const tunnelManager = getTunnelManager();
+    await tunnelManager.initialize();
+    if (tunnelManager.hasTunnel(moduleUid)) {
+      console.log(`[Daemon] EP959: Tunnel already running for ${moduleUid}`);
+      return;
+    }
+    try {
+      const config = await (0, import_core10.loadConfig)();
+      const apiUrl = config?.api_url || "https://episoda.dev";
+      const devServerScript = config?.project_settings?.worktree_dev_server_script;
+      const port = allocatePort(moduleUid);
+      console.log(`[Daemon] EP959: Post-setup tunnel start for ${moduleUid} on port ${port}`);
+      const devServerResult = await ensureDevServer(worktreePath, port, moduleUid, devServerScript);
+      if (!devServerResult.success) {
+        console.error(`[Daemon] EP959: Dev server failed for ${moduleUid}: ${devServerResult.error}`);
+        releasePort(moduleUid);
+        return;
+      }
+      const startResult = await tunnelManager.startTunnel({
+        moduleUid,
+        port,
+        onUrl: async (url) => {
+          console.log(`[Daemon] EP959: Tunnel URL for ${moduleUid}: ${url}`);
+          try {
+            await fetchWithAuth(`${apiUrl}/api/modules/${moduleUid}/tunnel`, {
+              method: "POST",
+              body: JSON.stringify({ tunnel_url: url })
+            });
+          } catch (err) {
+            console.warn(`[Daemon] EP959: Failed to report tunnel URL:`, err instanceof Error ? err.message : err);
+          }
+        },
+        onStatusChange: (status, error) => {
+          if (status === "error") {
+            console.error(`[Daemon] EP959: Tunnel error for ${moduleUid}: ${error}`);
+          }
+        }
+      });
+      if (startResult.success) {
+        console.log(`[Daemon] EP959: Tunnel started for ${moduleUid}`);
+      } else {
+        console.error(`[Daemon] EP959: Tunnel failed for ${moduleUid}: ${startResult.error}`);
+        releasePort(moduleUid);
+      }
+    } catch (error) {
+      console.error(`[Daemon] EP959: Error starting tunnel for ${moduleUid}:`, error);
+      releasePort(moduleUid);
+    }
+  }
   /**
    * EP819: Auto-start tunnels for active local modules on daemon connect/reconnect
    *
@@ -7235,8 +7594,9 @@ var Daemon = class _Daemon {
               tunnel_error: null
             });
             try {
+              const devServerScript = config.project_settings?.worktree_dev_server_script;
               console.log(`[Daemon] EP956: Ensuring dev server is running for ${moduleUid} at ${worktree.path}...`);
-              const devServerResult = await ensureDevServer(worktree.path, port, moduleUid);
+              const devServerResult = await ensureDevServer(worktree.path, port, moduleUid, devServerScript);
               if (!devServerResult.success) {
                 const errorMsg2 = `Dev server failed to start: ${devServerResult.error}`;
                 console.error(`[Daemon] EP956: ${errorMsg2}`);