@botonic/nx-plugin 2.31.0 → 2.32.0-alpha.0

package/src/executors/run-lambda/executor.js

@@ -21,45 +21,7 @@ __export(executor_exports, {
   default: () => runLambdaExecutor
 });
 module.exports = __toCommonJS(executor_exports);
-var import_child_process = require("child_process");
-var import_path = require("path");
-var import_executor_helpers = require("../../lib/util/executor-helpers");
-async function runLambdaExecutor(options, context) {
-  const projectRoot = (0, import_executor_helpers.resolveProjectPath)(context);
-  const lambdaPath = options.lambdaPath || "src/server/lambda";
-  const samCommand = options.samCommand || "sam local start-lambda";
-  const fullLambdaPath = (0, import_path.join)(projectRoot, lambdaPath);
-  console.info(`\u{1F680} Starting AWS SAM local lambda server...`);
-  console.info(`\u{1F4C1} Lambda directory: ${fullLambdaPath}`);
-  console.info(`\u{1F527} Command: ${samCommand}`);
-  return new Promise((resolve) => {
-    const [executable, ...args] = samCommand.split(" ");
-    const child = (0, import_child_process.spawn)(executable, args, {
-      cwd: fullLambdaPath,
-      stdio: "inherit",
-      // This will pipe stdout/stderr directly to the console
-      shell: true
-    });
-    child.on("error", (error) => {
-      console.error(`\u274C Error running lambda server:`, error.message);
-      resolve({ success: false });
-    });
-    child.on("close", (code) => {
-      if (code === 0) {
-        console.log("\u2705 Lambda server stopped successfully");
-        resolve({ success: true });
-      } else {
-        console.error(`\u274C Lambda server exited with code ${code}`);
-        resolve({ success: false });
-      }
-    });
-    process.on("SIGINT", () => {
-      console.log("\n\u{1F6D1} Stopping lambda server...");
-      child.kill("SIGINT");
-    });
-    process.on("SIGTERM", () => {
-      console.log("\n\u{1F6D1} Stopping lambda server...");
-      child.kill("SIGTERM");
-    });
-  });
+var import_delegate_executor = require("../../lib/delegate/delegate-executor");
+async function runLambdaExecutor(options, ctx) {
+  return (0, import_delegate_executor.runLocalExecutor)(__filename, "run-lambda", options, ctx);
 }

package/src/executors/serve-bot/executor-impl.d.ts

@@ -0,0 +1,5 @@
+import type { ExecutorContext } from '@nx/devkit';
+import type { ServeBotExecutorSchema } from './schema';
+export default function serveBotExecutor(options: ServeBotExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;

package/src/executors/serve-bot/executor-impl.js

@@ -0,0 +1,530 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var executor_impl_exports = {};
+__export(executor_impl_exports, {
+  default: () => serveBotExecutor
+});
+module.exports = __toCommonJS(executor_impl_exports);
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_path = require("path");
+var readline = __toESM(require("readline"));
+var import_cloudflared_tunnel = require("../../lib/cloudflared-tunnel");
+var import_executor_helpers = require("../../lib/util/executor-helpers");
+var import_sam_container_cleanup = require("../../lib/util/sam-container-cleanup");
+const colors = {
+  bot: "\x1B[36m",
+  // Cyan
+  lambda: "\x1B[33m",
+  // Yellow
+  webchat: "\x1B[32m",
+  // Green
+  webviews: "\x1B[35m",
+  // Magenta
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m"
+};
+let logFilePath = null;
+function initLogFile(projectRoot) {
+  const logsDir = (0, import_path.join)(projectRoot, ".botonic", "logs");
+  (0, import_fs.mkdirSync)(logsDir, { recursive: true });
+  const logPath = (0, import_path.join)(logsDir, "serve-bot.log");
+  (0, import_fs.writeFileSync)(logPath, "");
+  return logPath;
+}
+function writeToLogFile(line) {
+  if (logFilePath) {
+    try {
+      (0, import_fs.appendFileSync)(logFilePath, `${line}
+`);
+    } catch {
+    }
+  }
+}
+function checkFrontailInstalled(cwd) {
+  try {
+    (0, import_child_process.execSync)(`${cwd}/node_modules/.bin/frontail --help`, {
+      stdio: "pipe",
+      cwd
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function startFrontail(logPath, port, cwd) {
+  if (!checkFrontailInstalled(cwd)) {
+    console.warn(`${colors.bold}\u26A0\uFE0F  frontail is not installed.${colors.reset}`);
+    console.warn(
+      `   Run: ${colors.dim}pnpm install${colors.reset} to install dependencies
+`
+    );
+    return null;
+  }
+  const frontailProcess = (0, import_child_process.spawn)(
+    `${cwd}/node_modules/.bin/frontail`,
+    [
+      "--port",
+      port.toString(),
+      "--theme",
+      "dark",
+      "--lines",
+      "500",
+      "--ui-hide-topbar",
+      logPath
+    ],
+    {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      detached: false
+    }
+  );
+  frontailProcess.on("error", (error) => {
+    console.error(
+      `${colors.dim}[log-viewer]${colors.reset} Error: ${error.message}`
+    );
+  });
+  return frontailProcess;
+}
+function tryReadWebchatDevPort(projectRoot) {
+  try {
+    const configPath = (0, import_path.join)(projectRoot, "vite", "build.config.ts");
+    const content = (0, import_fs.readFileSync)(configPath, "utf8");
+    const match = content.match(/webchat:\s*\{\s*port:\s*(\d+)/);
+    if (match) return parseInt(match[1], 10);
+  } catch {
+  }
+  return 4201;
+}
+function getAppIdFromEnvFile(projectRoot) {
+  const envFilePath = (0, import_path.join)(projectRoot, ".env.local");
+  if (!(0, import_fs.existsSync)(envFilePath)) {
+    return null;
+  }
+  try {
+    const envContent = (0, import_fs.readFileSync)(envFilePath, "utf8");
+    const lines = envContent.split("\n");
+    const appIdKey = "VITE_HUBTYPE_APP_ID";
+    for (const line of lines) {
+      if (line.startsWith(`${appIdKey}=`)) {
+        return line.split("=")[1]?.trim();
+      }
+    }
+    return null;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`\u26A0\uFE0F  Could not read .env.local file: ${errorMessage}`);
+    return null;
+  }
+}
+function prefixOutput(stream, prefix, color) {
+  if (!stream) return;
+  const rl = readline.createInterface({ input: stream });
+  rl.on("line", (line) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    const formattedLine = `${colors.dim}${timestamp}${colors.reset} ${color}[${prefix}]${colors.reset} ${line}`;
+    console.log(formattedLine);
+    writeToLogFile(`${timestamp} [${prefix}] ${line}`);
+  });
+}
+function spawnProcess(command, name, color, cwd) {
+  const child = (0, import_child_process.spawn)("sh", ["-c", command], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, FORCE_COLOR: "1" }
+  });
+  prefixOutput(child.stdout, name, color);
+  prefixOutput(child.stderr, name, color);
+  return { name, color, process: child };
+}
+async function serveBotExecutor(options, context) {
+  if (!context.projectName) {
+    throw new Error("Project name is required");
+  }
+  const projectRoot = context.projectsConfigurations?.projects?.[context.projectName]?.root;
+  if (!projectRoot) {
+    throw new Error(`Could not find project root for ${context.projectName}`);
+  }
+  const configuration = options.configuration || "prod";
+  const fullProjectRoot = (0, import_path.join)(context.root, projectRoot);
+  const configPath = (0, import_path.join)(context.root, projectRoot, "vite.config.ts");
+  const appId = getAppIdFromEnvFile(fullProjectRoot);
+  if (!appId) {
+    console.warn(
+      `\u26A0\uFE0F  VITE_HUBTYPE_APP_ID not found in .env.local \u2014 will be set automatically after deploy`
+    );
+  }
+  console.log(`${colors.dim}Clearing Vite cache...${colors.reset}`);
+  const viteCacheDirs = [
+    (0, import_path.join)(context.root, "node_modules", ".vite"),
+    (0, import_path.join)(fullProjectRoot, "node_modules", ".vite"),
+    (0, import_path.join)(fullProjectRoot, ".vite")
+  ];
+  for (const dir of viteCacheDirs) {
+    try {
+      if ((0, import_fs.existsSync)(dir)) {
+        (0, import_child_process.execSync)(`rm -rf "${dir}"`, { stdio: "pipe" });
+      }
+    } catch {
+    }
+  }
+  console.log(`${colors.dim}Vite cache cleared.${colors.reset}`);
+  const cleanupResult = (0, import_sam_container_cleanup.cleanupPreviousSamContainersByLabel)(fullProjectRoot);
+  if (cleanupResult === "removed") {
+    console.log(
+      `${colors.dim}[lambda] Removed previous run's container (reused slot).${colors.reset}`
+    );
+  } else if (cleanupResult === "none") {
+    console.log(
+      `${colors.dim}[lambda] No previous Lambda container to clean up.${colors.reset}`
+    );
+  }
+  logFilePath = null;
+  const logViewerPort = options.logViewerPort ?? 9001;
+  const webchatDevPort = tryReadWebchatDevPort(fullProjectRoot);
+  logFilePath = initLogFile(fullProjectRoot);
+  const frontailProcess = startFrontail(
+    logFilePath,
+    logViewerPort,
+    context.root
+  );
+  const logViewerInfo = `${colors.dim}Webchat:${colors.reset}       ${colors.bold}http://localhost:${webchatDevPort}/?logs=${logViewerPort}${colors.reset} (with logs panel)
+${colors.dim}Log viewer:${colors.reset}    http://localhost:${logViewerPort}`;
+  const useTunnel = true;
+  const tunnelPort = options.tunnelPort ?? 3001;
+  let effectiveLambdaEndpoint = options.lambdaEndpoint;
+  let startLambda = !options.skipLambda && !effectiveLambdaEndpoint;
+  let tunnelDeployResult;
+  let devSessionLambdaFunctionName;
+  let registeredTunnelUrl;
+  let deployedBotId;
+  let selectedBotId;
+  let deployedApiUrl;
+  let deployedAccessToken;
+  let deployedRefreshToken;
+  let deployedClientId;
+  if (useTunnel) {
+    await (0, import_executor_helpers.ensureHubtypeLoginBeforeTunnel)(context, fullProjectRoot, {
+      env: options.env,
+      configuration
+    });
+    try {
+      selectedBotId = await (0, import_executor_helpers.selectBotForServe)(context, fullProjectRoot, {
+        env: options.env,
+        configuration,
+        botName: options.botName
+      });
+    } catch (botDeployErr) {
+      if ((0, import_executor_helpers.isBotDeployedRestartRequired)(botDeployErr)) {
+        if (frontailProcess) {
+          frontailProcess.kill("SIGTERM");
+        }
+        if (process.stdin.isTTY) {
+          try {
+            process.stdin.setRawMode(false);
+          } catch {
+          }
+        }
+        process.stdin.pause();
+        process.stdin.unref();
+        return { success: true };
+      }
+      throw botDeployErr;
+    }
+    console.log(
+      `${colors.dim}Starting tunnel flow (Lambda + cloudflared + dev session registration)...${colors.reset}
+`
+    );
+  }
+  const processes = [];
+  try {
+    if (useTunnel) {
+      const lambdaPath = (0, import_path.join)(fullProjectRoot, "src/server/lambda");
+      const lambdaCommand = "sam local start-lambda --warm-containers EAGER --skip-pull-image";
+      processes.push(
+        spawnProcess(lambdaCommand, "lambda", colors.lambda, lambdaPath)
+      );
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      console.log(
+        `${colors.dim}Starting Cloudflare tunnel (cloudflared)...${colors.reset}`
+      );
+      const { url: tunnelUrl, process: cloudflaredProcess } = await (0, import_cloudflared_tunnel.startCloudflaredTunnel)(tunnelPort);
+      processes.push({
+        name: "tunnel",
+        color: colors.lambda,
+        process: cloudflaredProcess
+      });
+      console.log(`${colors.dim}Tunnel URL: ${tunnelUrl}${colors.reset}
+`);
+      console.log(
+        `${colors.dim}Setting up dev bot and writing dev session env vars...${colors.reset}`
+      );
+      const deployResult = await (0, import_executor_helpers.performDeployLocalRuntimeWithEndpoint)(
+        context,
+        fullProjectRoot,
+        tunnelUrl,
+        {
+          env: options.env,
+          configuration,
+          whatsappPhone: options.phone,
+          selectedBotId
+        }
+      );
+      tunnelDeployResult = {
+        targetEnvironment: deployResult.targetEnvironment,
+        environmentVariables: deployResult.environmentVariables,
+        teardownWebchat: deployResult.teardownWebchat
+      };
+      devSessionLambdaFunctionName = deployResult.lambdaFunctionName;
+      registeredTunnelUrl = tunnelUrl;
+      deployedBotId = deployResult.botId ?? "";
+      deployedApiUrl = deployResult.apiUrl ?? "https://api.hubtype.com";
+      deployedAccessToken = deployResult.accessToken ?? "";
+      deployedRefreshToken = deployResult.refreshToken ?? "";
+      deployedClientId = deployResult.clientId ?? "";
+      const resolvedEnv = ["local", "dev", "dev2", "qa", "prod"].includes(deployResult.targetEnvironment) ? deployResult.targetEnvironment : "local";
+      (0, import_executor_helpers.writeEnvVarToEnvFile)(
+        fullProjectRoot,
+        "VITE_DEV_SESSION_URL",
+        tunnelUrl,
+        resolvedEnv
+      );
+      if (devSessionLambdaFunctionName) {
+        (0, import_executor_helpers.writeEnvVarToEnvFile)(
+          fullProjectRoot,
+          "VITE_DEV_LAMBDA_FUNCTION_NAME",
+          devSessionLambdaFunctionName,
+          resolvedEnv
+        );
+      }
+      (0, import_executor_helpers.writeEnvVarToEnvFile)(
+        fullProjectRoot,
+        "VITE_DEV_BOT_ID",
+        deployResult.botId ?? "",
+        resolvedEnv
+      );
+      (0, import_executor_helpers.writeEnvVarToEnvFile)(
+        fullProjectRoot,
+        "VITE_DEV_API_URL",
+        deployResult.apiUrl ?? "https://api.hubtype.com",
+        resolvedEnv
+      );
+      (0, import_executor_helpers.writeEnvVarToEnvFile)(
+        fullProjectRoot,
+        "VITE_DEV_ACCESS_TOKEN",
+        deployResult.accessToken ?? "",
+        resolvedEnv
+      );
+      (0, import_executor_helpers.writeEnvVarToEnvFile)(
+        fullProjectRoot,
+        "VITE_DEV_REFRESH_TOKEN",
+        deployResult.refreshToken ?? "",
+        resolvedEnv
+      );
+      (0, import_executor_helpers.writeEnvVarToEnvFile)(
+        fullProjectRoot,
+        "VITE_DEV_CLIENT_ID",
+        deployResult.clientId ?? "",
+        resolvedEnv
+      );
+      console.log(
+        `${colors.dim}VITE_DEV_SESSION_URL written to .env.${resolvedEnv}${colors.reset}`
+      );
+      effectiveLambdaEndpoint = tunnelUrl;
+      startLambda = false;
+    }
+  } catch (tunnelError) {
+    const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
+    console.error(`\u274C Tunnel flow failed: ${msg}`);
+    if (frontailProcess) {
+      frontailProcess.kill("SIGTERM");
+    }
+    return { success: false };
+  }
+  let effectiveAppId = appId;
+  if (useTunnel) {
+    const latestAppId = (0, import_executor_helpers.getAppIdFromEnvFileForConfig)(
+      fullProjectRoot,
+      configuration
+    );
+    if (latestAppId) effectiveAppId = latestAppId;
+  }
+  if (configuration !== "local" && effectiveAppId) {
+    await (0, import_executor_helpers.writeAppIdToEnvFile)(fullProjectRoot, effectiveAppId, configuration);
+  }
+  const useExternalLambda = Boolean(effectiveLambdaEndpoint);
+  if (!useTunnel) {
+    startLambda = !options.skipLambda && !useExternalLambda;
+  }
+  console.log(`
+${colors.bold}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551              \u{1F680} Botonic Dev Server                         \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D${colors.reset}
+
+${colors.dim}Project:${colors.reset}       ${context.projectName}
+${colors.dim}Configuration:${colors.reset} ${configuration}
+${colors.dim}App ID:${colors.reset}        ${effectiveAppId}
+${logViewerInfo}
+${useExternalLambda ? `${colors.dim}Lambda (external):${colors.reset} ${effectiveLambdaEndpoint}
+` : ""}
+${colors.bot}[bot]${colors.reset}      - Node/Lambda build watcher
+${startLambda ? `${colors.lambda}[lambda]${colors.reset}   - AWS SAM local lambda server` : useExternalLambda ? `${colors.lambda}[lambda]${colors.reset}   - Using external endpoint (no Docker)` : ""}
+${colors.webchat}[webchat]${colors.reset}  - Webchat Vite dev server
+${colors.webviews}[webviews]${colors.reset} - Webviews Vite dev server
+`);
+  if (useExternalLambda && !useTunnel) {
+    console.log(
+      `${colors.dim}\u{1F4A1} Ensure you have run the serve target first to register your dev session.${colors.reset}
+`
+    );
+  }
+  for (const dir of viteCacheDirs) {
+    try {
+      if ((0, import_fs.existsSync)(dir)) {
+        (0, import_child_process.execSync)(`rm -rf "${dir}"`, { stdio: "pipe" });
+      }
+    } catch {
+    }
+  }
+  try {
+    const buildCommand = `VITE_CJS_IGNORE_WARNING=true BUILD_TARGET=node vite build --config ${configPath} --watch`;
+    processes.push(
+      spawnProcess(buildCommand, "bot", colors.bot, fullProjectRoot)
+    );
+    await new Promise((resolve) => setTimeout(resolve, 3e3));
+    if (startLambda) {
+      const lambdaPath = (0, import_path.join)(fullProjectRoot, "src/server/lambda");
+      const lambdaCommand = "sam local start-lambda --warm-containers EAGER --skip-pull-image";
+      processes.push(
+        spawnProcess(lambdaCommand, "lambda", colors.lambda, lambdaPath)
+      );
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+    }
+    const noOpenEnv = options.open === false ? "VITE_SERVE_OPEN=false " : "";
+    const viteEnvAppId = `VITE_HUBTYPE_APP_ID=${effectiveAppId}`;
+    const viteDevSessionEnv = registeredTunnelUrl && devSessionLambdaFunctionName ? `VITE_DEV_SESSION_URL=${registeredTunnelUrl} VITE_DEV_LAMBDA_FUNCTION_NAME=${devSessionLambdaFunctionName} ` : "";
+    const viteDevCredentialsEnv = deployedBotId ? [
+      `VITE_DEV_BOT_ID=${deployedBotId}`,
+      `VITE_DEV_API_URL=${deployedApiUrl ?? "https://api.hubtype.com"}`,
+      `VITE_DEV_ACCESS_TOKEN=${deployedAccessToken ?? ""}`,
+      `VITE_DEV_REFRESH_TOKEN=${deployedRefreshToken ?? ""}`,
+      `VITE_DEV_CLIENT_ID=${deployedClientId ?? ""}`
+    ].join(" ") + " " : "";
+    const logViewerEnv = `LOG_VIEWER_PORT=${logViewerPort} `;
+    const botHasWhatsapp = deployedBotId ? (0, import_executor_helpers.selectedBotHasActiveWhatsapp)(deployedBotId) : false;
+    const whatsappPanelEnv = botHasWhatsapp ? `BOT_HAS_WHATSAPP=1 ${options.phone ? `WHATSAPP_PANEL_PHONE=${options.phone} ` : ""}` : "";
+    const webchatCommand = `${noOpenEnv}${logViewerEnv}${viteDevSessionEnv}${viteDevCredentialsEnv}${whatsappPanelEnv}${viteEnvAppId} TARGET_APP=webchat MODE=${configuration} vite --config ${configPath}`;
+    processes.push(
+      spawnProcess(webchatCommand, "webchat", colors.webchat, fullProjectRoot)
+    );
+    if (!options.skipWebviews) {
+      const webviewsCommand = `${noOpenEnv}${viteDevSessionEnv}${viteEnvAppId} TARGET_APP=webviews MODE=${configuration} vite --config ${configPath}`;
+      processes.push(
+        spawnProcess(
+          webviewsCommand,
+          "webviews",
+          colors.webviews,
+          fullProjectRoot
+        )
+      );
+    }
+    let cleanupCalled = false;
+    const cleanup = () => {
+      if (cleanupCalled) return;
+      cleanupCalled = true;
+      console.log(
+        `
+${colors.bold}\u{1F6D1} Shutting down all processes...${colors.reset}`
+      );
+      try {
+        const envConfig = ["local", "dev", "dev2", "qa", "prod"].includes(tunnelDeployResult?.targetEnvironment ?? "") ? tunnelDeployResult.targetEnvironment : "local";
+        (0, import_executor_helpers.writeEnvVarToEnvFile)(
+          fullProjectRoot,
+          "VITE_DEV_SESSION_URL",
+          "",
+          envConfig
+        );
+        (0, import_executor_helpers.writeEnvVarToEnvFile)(
+          fullProjectRoot,
+          "VITE_DEV_LAMBDA_FUNCTION_NAME",
+          "",
+          envConfig
+        );
+      } catch {
+      }
+      processes.forEach(({ name, color, process: proc }) => {
+        console.log(`${color}[${name}]${colors.reset} Stopping...`);
+        proc.kill("SIGTERM");
+      });
+      if (frontailProcess) {
+        console.log(
+          `${colors.dim}[log-viewer]${colors.reset} Stopping log viewer...`
+        );
+        frontailProcess.kill("SIGTERM");
+      }
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    process.on("exit", cleanup);
+    return new Promise((resolve) => {
+      let exitCount = 0;
+      const totalProcesses = processes.length;
+      processes.forEach(({ name, color, process: proc }) => {
+        proc.on("exit", (code) => {
+          console.log(
+            `${color}[${name}]${colors.reset} Process exited with code ${code}`
+          );
+          exitCount++;
+          if (code !== 0 && code !== null) {
+            cleanup();
+            resolve({ success: false });
+          }
+          if (exitCount === totalProcesses) {
+            resolve({ success: true });
+          }
+        });
+        proc.on("error", (error) => {
+          console.error(
+            `${color}[${name}]${colors.reset} Error: ${error.message}`
+          );
+          cleanup();
+          resolve({ success: false });
+        });
+      });
+    });
+  } catch (error) {
+    if ((0, import_executor_helpers.isBotDeployedRestartRequired)(error)) {
+      return { success: true };
+    }
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C Error starting dev server:`, errorMessage);
+    return { success: false };
+  }
+}

package/src/executors/serve-bot/executor.d.ts

@@ -1,5 +1,7 @@
 import type { ExecutorContext } from '@nx/devkit';
 import type { ServeBotExecutorSchema } from './schema';
-export default function serveBotExecutor(options: ServeBotExecutorSchema, context: ExecutorContext): Promise<{
+export default function serveBotExecutor(options: ServeBotExecutorSchema, ctx: ExecutorContext): Promise<{
     success: boolean;
-}>;
+} | AsyncIterableIterator<{
+    success: boolean;
+}>>;