@botonic/nx-plugin 2.29.0 → 2.31.0

package/src/lib/util/executor-helpers.js

@@ -22,34 +22,39 @@ __export(executor_helpers_exports, {
   askLogin: () => askLogin,
   askSignup: () => askSignup,
   createNewBotWithName: () => createNewBotWithName,
+  deployBotToHubtype: () => deployBotToHubtype,
+  ensureBot: () => ensureBot,
   ensureHubtypeLoginBeforeTunnel: () => ensureHubtypeLoginBeforeTunnel,
-  ensureLocalRuntimeBot: () => ensureLocalRuntimeBot,
-  ensureLocalRuntimeBotBeforeTunnel: () => ensureLocalRuntimeBotBeforeTunnel,
   findMatchingConfigurationKey: () => findMatchingConfigurationKey,
+  getActiveTestWebchatProviderAppId: () => getActiveTestWebchatProviderAppId,
+  getActiveWebchatProviderAppId: () => getActiveWebchatProviderAppId,
   getAppIdFromEnvFile: () => getAppIdFromEnvFile,
   getAppIdFromEnvFileForConfig: () => getAppIdFromEnvFileForConfig,
   getAvailableBots: () => getAvailableBots,
   handleAuthentication: () => handleAuthentication,
   handleExecutorError: () => handleExecutorError,
+  isBotDeployedRestartRequired: () => isBotDeployedRestartRequired,
   logWorkingAsAndEnvironment: () => logWorkingAsAndEnvironment,
   performDeployLocalRuntimeWithEndpoint: () => performDeployLocalRuntimeWithEndpoint,
-  removeAppBotonicJson: () => removeAppBotonicJson,
   resolveHubtypeEnvironment: () => resolveHubtypeEnvironment,
   resolveProjectPath: () => resolveProjectPath,
+  selectBotForServe: () => selectBotForServe,
+  selectedBotHasActiveWhatsapp: () => selectedBotHasActiveWhatsapp,
   writeAppIdToEnvFile: () => writeAppIdToEnvFile,
   writeAppIdToLocalEnv: () => writeAppIdToLocalEnv,
-  writeEnvVarToEnvFile: () => writeEnvVarToEnvFile,
-  writeLocalRuntimeBotToAppFolder: () => writeLocalRuntimeBotToAppFolder
+  writeEnvVarToEnvFile: () => writeEnvVarToEnvFile
 });
 module.exports = __toCommonJS(executor_helpers_exports);
 var import_enquirer = require("enquirer");
 var import_fs = require("fs");
+var import_os = require("os");
 var import_path = require("path");
+var import_zip_a_folder = require("zip-a-folder");
 var import_api_service = require("../api-service");
 var import_bot_config = require("../bot-config");
-var import_constants = require("../constants");
 var import_file_system = require("./file-system");
 var import_sam_template = require("./sam-template");
+var import_system = require("./system");
 function resolveProjectPath(context) {
   if (!context.projectName) {
     throw new Error("Project name is not defined in executor context");
@@ -139,14 +144,14 @@ async function getAvailableBots(botonicApiService) {
   return resp.data.results;
 }
 const MAX_BOT_NAME_LENGTH = 25;
-async function createNewBotWithName(botonicApiService, botName) {
+async function createNewBotWithName(botonicApiService, botName, isTest = false) {
   if (botName.length > MAX_BOT_NAME_LENGTH) {
     throw new Error(
       `Bot name must be at most ${MAX_BOT_NAME_LENGTH} characters. Please choose a shorter name.`
     );
   }
   console.log(`\u{1F916} Creating bot "${botName}"...`);
-  await botonicApiService.createBot(botName);
+  await botonicApiService.createBot(botName, isTest);
   console.log(`\u2705 Bot "${botName}" created successfully!`);
 }
 function getAppIdFromEnvFile(projectRoot, appIdKey) {
@@ -366,9 +371,7 @@ async function ensureHubtypeLoginBeforeTunnel(context, projectRoot, options = {}
     options
   );
   const botonicApiService = new import_api_service.BotonicAPIService({
-    isLocalRuntimeDeployment: true,
     projectRoot,
-    workspaceRoot: (0, import_path.resolve)(context.root),
     environmentVariables,
     targetEnvironment
   });
@@ -382,63 +385,15 @@ async function ensureHubtypeLoginBeforeTunnel(context, projectRoot, options = {}
   }
   await logWorkingAsAndEnvironment(botonicApiService);
 }
-async function ensureLocalRuntimeBotBeforeTunnel(context, projectRoot, options = {}) {
-  const { targetEnvironment, environmentVariables } = resolveHubtypeEnvironment(
-    context,
-    options
-  );
-  const botonicApiService = new import_api_service.BotonicAPIService({
-    isLocalRuntimeDeployment: true,
-    projectRoot,
-    workspaceRoot: (0, import_path.resolve)(context.root),
-    environmentVariables,
-    targetEnvironment
-  });
-  if (!botonicApiService.oauth) {
-    if (options.email && options.password) {
-      await botonicApiService.login(options.email, options.password);
-      botonicApiService.saveAllCredentials();
-    } else {
-      await handleAuthentication(botonicApiService);
-    }
-  }
-  await ensureLocalRuntimeBot(botonicApiService);
-  writeLocalRuntimeBotToAppFolder(projectRoot, botonicApiService.botInfo());
-  botonicApiService.saveAllCredentials();
-}
-function writeLocalRuntimeBotToAppFolder(projectRoot, bot) {
-  const path = (0, import_path.join)(projectRoot, import_constants.BOT_CREDENTIALS_FILENAME);
-  (0, import_file_system.writeJSON)(path, { bot });
-}
-function removeAppBotonicJson(projectRoot) {
-  const path = (0, import_path.join)(projectRoot, import_constants.BOT_CREDENTIALS_FILENAME);
-  if ((0, import_fs.existsSync)(path)) {
-    (0, import_fs.unlinkSync)(path);
-  }
-}
-async function promptConfirmStagingBot(botName) {
-  console.log(
-    `
-\u26A0\uFE0F  Bot "${botName}" will be created as a staging bot on the Hubtype platform.`
-  );
-  console.log(
-    `   To create a production bot, use the Hubtype dashboard or the deploy-to-hubtype command instead.
-`
-  );
-  const confirmation = await (0, import_enquirer.prompt)({
-    type: "confirm",
-    name: "confirm_staging",
-    message: "\u{1F6A6} Do you want to proceed?"
-  });
-  return confirmation.confirm_staging;
-}
-async function ensureLocalRuntimeBot(botonicApiService) {
-  if (botonicApiService.hasLocalRuntimeBot()) {
+async function ensureBot(botonicApiService) {
+  if (botonicApiService.bot) {
     return;
   }
   const bots = await getAvailableBots(botonicApiService);
   if (bots.length === 0) {
-    console.log("\u{1F916} No bots yet. Let's create one for local runtime.\n");
+    console.log(
+      "\u{1F916} No bots found. Let's create one.\n   \u26A0\uFE0F  After creating, you'll need to deploy it with 'nx run <bot>:deploy-to-hubtype' before serve will work.\n"
+    );
     const response2 = await (0, import_enquirer.prompt)({
       type: "input",
       name: "bot_name",
@@ -452,18 +407,17 @@ async function ensureLocalRuntimeBot(botonicApiService) {
       }
     });
     const name = response2.bot_name.trim();
-    if (!await promptConfirmStagingBot(name)) {
-      throw new Error("Bot creation cancelled.");
-    }
     await createNewBotWithName(botonicApiService, name);
     return;
   }
-  const CREATE_NEW_CHOICE = "__create_new__";
-  console.log("\u{1F4CB} Select a bot for local runtime or create a new one:\n");
+  const CREATE_NEW_CHOICE = "New Bot";
+  console.log(
+    "\u{1F4CB} Select a deployed bot to use for local development, or create a new one:\n   \u2139\uFE0F  The bot must already be deployed (botonic_v2 strategy) for serve to work.\n"
+  );
   const response = await (0, import_enquirer.prompt)({
     type: "select",
     name: "bot_id",
-    message: "\u{1F916} Select a bot or create new:",
+    message: "\u{1F916} Select a bot:",
     choices: [
       ...bots.map((bot2) => ({
         name: bot2.id,
@@ -473,6 +427,9 @@ async function ensureLocalRuntimeBot(botonicApiService) {
     ]
   });
   if (response.bot_id === CREATE_NEW_CHOICE) {
+    console.log(
+      "   \u26A0\uFE0F  After creating, you'll need to deploy it with 'nx run <bot>:deploy-to-hubtype' before serve will work.\n"
+    );
     const nameResponse = await (0, import_enquirer.prompt)({
       type: "input",
       name: "bot_name",
@@ -486,19 +443,38 @@ async function ensureLocalRuntimeBot(botonicApiService) {
       }
     });
     const name = nameResponse.bot_name.trim();
-    if (!await promptConfirmStagingBot(name)) {
-      throw new Error("Bot creation cancelled.");
-    }
     await createNewBotWithName(botonicApiService, name);
     return;
   }
   const bot = bots.find((b) => b.id === response.bot_id);
-  if (bot) {
-    botonicApiService.setLocalRuntimeBot(bot);
-    console.log(`\u2705 Selected bot: ${bot.name}`);
-  } else {
+  if (!bot) {
     throw new Error("Bot selection failed");
   }
+  await botonicApiService.selectBot(bot);
+  console.log(`\u2705 Selected bot: ${bot.name}`);
+}
+async function refreshBotProviders(botonicApiService) {
+  process.stdout.write("\u23F3 Fetching bot information...");
+  try {
+    const providers = await botonicApiService.fetchProviders(
+      botonicApiService.botInfo().id
+    );
+    botonicApiService.saveProviders(providers);
+    process.stdout.write("\r\u2705 Bot information fetched.             \n");
+  } catch {
+    process.stdout.write("\r\u26A0\uFE0F  Could not fetch bot information.    \n");
+  }
+}
+const WEBCHAT_PROVIDER = "webchat";
+function getActiveWebchatProviderAppId(results) {
+  return results?.find(
+    (p) => !p.is_test && Boolean(p.is_active) && p.provider === WEBCHAT_PROVIDER
+  )?.id;
+}
+function getActiveTestWebchatProviderAppId(results) {
+  return results?.find(
+    (p) => Boolean(p.is_test) && Boolean(p.is_active) && p.provider === WEBCHAT_PROVIDER
+  )?.id;
 }
 async function performDeployLocalRuntimeWithEndpoint(context, projectRoot, endpoint, options = {}) {
   const { targetEnvironment, environmentVariables } = resolveHubtypeEnvironment(
@@ -506,9 +482,7 @@ async function performDeployLocalRuntimeWithEndpoint(context, projectRoot, endpo
     options
   );
   const botonicApiService = new import_api_service.BotonicAPIService({
-    isLocalRuntimeDeployment: true,
     projectRoot,
-    workspaceRoot: (0, import_path.resolve)(context.root),
     environmentVariables,
     targetEnvironment
   });
@@ -520,41 +494,72 @@ async function performDeployLocalRuntimeWithEndpoint(context, projectRoot, endpo
       await handleAuthentication(botonicApiService);
     }
   }
+  if (options.selectedBotId && botonicApiService.bot?.id !== options.selectedBotId) {
+    const bots = await getAvailableBots(botonicApiService);
+    const bot = bots.find((b) => b.id === options.selectedBotId);
+    if (bot) await botonicApiService.selectBot(bot);
+  }
   const maxAttempts = 2;
   let lastError;
   for (let attempt = 1; attempt <= maxAttempts; attempt++) {
     try {
-      await ensureLocalRuntimeBot(botonicApiService);
-      writeLocalRuntimeBotToAppFolder(projectRoot, botonicApiService.botInfo());
-      const functionName = (0, import_sam_template.getLocalLambdaFunctionName)(projectRoot);
+      await ensureBot(botonicApiService);
+      await refreshBotProviders(botonicApiService);
+      const lambdaFunctionName = (0, import_sam_template.getLocalLambdaFunctionName)(projectRoot);
       const botConfigJson = await import_bot_config.BotConfig.get(projectRoot);
-      await botonicApiService.deployLocalRuntime({
-        botConfigJson,
-        lambdaFunctionName: functionName,
-        lambdaEndpoint: endpoint
-      });
-      const providersResp = await botonicApiService.getProviders();
-      const appId = providersResp.data.results?.filter(
-        (p) => p.is_test && p.is_active
-      )[0]?.id;
-      const resolvedTargetEnv = TARGET_ENV_NAMES.includes(
-        targetEnvironment
-      ) ? targetEnvironment : "local";
+      await botonicApiService.refreshTokenIfNeeded();
+      const botId = botonicApiService.botInfo().id;
+      if (options.whatsappPhone) {
+        try {
+          await botonicApiService.registerDevSessionWhatsapp(
+            botId,
+            options.whatsappPhone,
+            endpoint,
+            lambdaFunctionName,
+            botConfigJson
+          );
+        } catch (regErr) {
+          throwIfBotNotDeployed(regErr, botonicApiService.botInfo().name);
+          throw regErr;
+        }
+        console.log(
+          `\u2705 WhatsApp local routing registered for ${options.whatsappPhone}`
+        );
+      } else {
+        console.log(
+          `\u2705 Webchat local routing ready (registration deferred until user connects)`
+        );
+      }
+      const providers = botonicApiService.bot?.providers ?? [];
+      const appId = getActiveWebchatProviderAppId(providers) ?? getActiveTestWebchatProviderAppId(providers);
       if (appId) {
+        const resolvedTargetEnv = TARGET_ENV_NAMES.includes(
+          targetEnvironment
+        ) ? targetEnvironment : "local";
         await writeAppIdToEnvFile(projectRoot, appId, resolvedTargetEnv);
+      } else {
+        console.warn(
+          "\u26A0\uFE0F  No active webchat provider found for this bot. Set VITE_HUBTYPE_APP_ID manually in .env to use the local webchat widget."
+        );
       }
       botonicApiService.saveAllCredentials();
       return {
-        botId: botonicApiService.botInfo().id,
+        botId,
+        apiUrl: botonicApiService.baseUrl,
+        accessToken: botonicApiService.getOauth().access_token ?? "",
+        refreshToken: botonicApiService.getOauth().refresh_token ?? "",
+        clientId: botonicApiService.clientId,
         targetEnvironment,
-        environmentVariables
+        environmentVariables,
+        lambdaFunctionName,
+        teardownWebchat: async () => {
+        }
       };
     } catch (err) {
       lastError = err;
       const status = err?.response?.status;
       if (status === 404 && attempt < maxAttempts) {
-        removeAppBotonicJson(projectRoot);
-        botonicApiService.setLocalRuntimeBot(null);
+        botonicApiService.setCurrentBot(null);
         continue;
       }
       throw err;
@@ -562,28 +567,422 @@ async function performDeployLocalRuntimeWithEndpoint(context, projectRoot, endpo
   }
   throw lastError;
 }
+function throwIfBotNotDeployed(err, botName) {
+  const data = err?.response?.data;
+  const message = typeof data === "string" ? data : JSON.stringify(data ?? "");
+  if (message.includes("deployed Botonic v2 bot") || message.includes("deployment_strategy")) {
+    throw new Error(
+      `\u274C Bot "${botName}" must be deployed before it can be used for local development.
+   Run: nx run <bot>:deploy-to-hubtype
+   Then retry: nx run <bot>:serve`
+    );
+  }
+}
+async function selectBotForServe(context, projectRoot, options = {}) {
+  const { targetEnvironment, environmentVariables } = resolveHubtypeEnvironment(
+    context,
+    options
+  );
+  const botonicApiService = new import_api_service.BotonicAPIService({
+    projectRoot,
+    environmentVariables,
+    targetEnvironment
+  });
+  const projectName = context.projectName ?? "";
+  if (options.botName) {
+    await selectBotByName(
+      botonicApiService,
+      options.botName,
+      projectRoot,
+      projectName,
+      targetEnvironment
+    );
+  } else {
+    await selectBotInteractive(
+      botonicApiService,
+      projectRoot,
+      projectName,
+      targetEnvironment
+    );
+  }
+  const selectedBotId = botonicApiService.bot?.id;
+  if (selectedBotId) {
+    const resolvedEnv = TARGET_ENV_NAMES.includes(
+      targetEnvironment
+    ) ? targetEnvironment : "local";
+    writeEnvVarToEnvFile(
+      projectRoot,
+      "VITE_DEV_BOT_ID",
+      selectedBotId,
+      resolvedEnv
+    );
+  }
+  return selectedBotId;
+}
+async function selectBotByName(botonicApiService, botName, projectRoot, projectName, configuration) {
+  const bots = await getAvailableBots(botonicApiService);
+  const bot = bots.find((b) => b.name === botName);
+  if (bot) {
+    if (!bot.is_test) {
+      throw new Error(
+        `Bot "${botName}" is a production bot and cannot be used for local development. Use a staging bot instead.`
+      );
+    }
+    await botonicApiService.selectBot(bot);
+    console.log(`\u2705 Selected bot: ${botLabel(bot)}`);
+  } else {
+    console.log(
+      `\u{1F916} Bot "${botName}" not found. Creating it as a staging bot...`
+    );
+    await createNewBotWithName(botonicApiService, botName, true);
+    await autoDeploy(
+      botonicApiService,
+      projectRoot,
+      projectName,
+      botName,
+      configuration
+    );
+  }
+  botonicApiService.saveAllCredentials();
+}
+const CREATE_STAGING_CHOICE = "Create Staging Bot";
+function botLabel(bot) {
+  return bot.is_test ? `${bot.name} (Staging bot)` : `${bot.name} (Production bot)`;
+}
+const CHANNEL_ICONS = {
+  whatsapp: "\u{1F4AC} WhatsApp",
+  webchat: "\u{1F310} Webchat",
+  facebook: "\u{1F499} Facebook",
+  telegram: "\u2708\uFE0F  Telegram",
+  twitter: "\u{1F426} Twitter"
+};
+function botLabelWithChannels(bot) {
+  const base = botLabel(bot);
+  const activeChannels = (bot.providers ?? []).filter((p) => p.is_active).map((p) => CHANNEL_ICONS[p.provider] ?? p.provider);
+  return activeChannels.length > 0 ? `${base} \u2014 ${activeChannels.join(", ")}` : base;
+}
+async function promptNewBotName() {
+  const response = await (0, import_enquirer.prompt)({
+    type: "input",
+    name: "bot_name",
+    message: "\u{1F916} Bot name:",
+    validate: (input) => {
+      if (!input.trim()) return "Bot name cannot be empty";
+      if (input.length > MAX_BOT_NAME_LENGTH) {
+        return `Bot name must be at most ${MAX_BOT_NAME_LENGTH} characters`;
+      }
+      return true;
+    }
+  });
+  return response.bot_name.trim();
+}
+async function selectBotInteractive(botonicApiService, projectRoot, projectName, configuration) {
+  const bots = await getAvailableBots(botonicApiService);
+  if (bots.length === 0) {
+    console.log("\u{1F916} No bots found. Creating a new one for local development.\n");
+    const name = await promptNewBotName();
+    await createNewBotWithName(botonicApiService, name, true);
+    await autoDeploy(
+      botonicApiService,
+      projectRoot,
+      projectName,
+      name,
+      configuration
+    );
+    return;
+  }
+  const stagingBots = bots.filter((b) => b.is_test);
+  if (stagingBots.length === 0) {
+    console.log(
+      "\u{1F916} No staging bots found. Creating one for local development.\n"
+    );
+    const name = await promptNewBotName();
+    await createNewBotWithName(botonicApiService, name, true);
+    await autoDeploy(
+      botonicApiService,
+      projectRoot,
+      projectName,
+      name,
+      configuration
+    );
+    return;
+  }
+  process.stdout.write("\u23F3 Fetching bot information...");
+  const botsWithProviders = await Promise.all(
+    stagingBots.map(async (bot2) => {
+      try {
+        const providers = await botonicApiService.fetchProviders(bot2.id);
+        const enriched = { ...bot2, providers };
+        botonicApiService.saveBotEntry(enriched);
+        return enriched;
+      } catch {
+        return bot2;
+      }
+    })
+  );
+  process.stdout.write("\r\u2705 Bot information fetched.             \n");
+  const previousBotId = botonicApiService.bot?.id;
+  const sortedBots = [...botsWithProviders].sort(
+    (a, b) => {
+      if (a.id === previousBotId) return -1;
+      if (b.id === previousBotId) return 1;
+      return 0;
+    }
+  );
+  console.log("\u{1F4CB} Select a bot for local development:\n");
+  const response = await (0, import_enquirer.prompt)({
+    type: "select",
+    name: "bot_id",
+    message: "\u{1F916} Select a bot:",
+    // initial: 0 defaults to the first item (previously used bot after sort)
+    initial: 0,
+    choices: [
+      ...sortedBots.map((bot2) => ({
+        name: bot2.id,
+        message: botLabelWithChannels(bot2)
+      })),
+      {
+        name: CREATE_STAGING_CHOICE,
+        message: "+ Create Staging Bot  (recommended for dev sessions)"
+      }
+    ]
+  });
+  if (response.bot_id === CREATE_STAGING_CHOICE) {
+    const name = await promptNewBotName();
+    await createNewBotWithName(botonicApiService, name, true);
+    await autoDeploy(
+      botonicApiService,
+      projectRoot,
+      projectName,
+      name,
+      configuration
+    );
+    return;
+  }
+  const bot = sortedBots.find((b) => b.id === response.bot_id);
+  if (!bot) {
+    throw new Error("Bot selection failed");
+  }
+  await botonicApiService.selectBot(bot);
+  console.log(
+    `\u2705 Selected bot: ${botLabel(bot)}`
+  );
+  botonicApiService.saveAllCredentials();
+}
+async function autoDeploy(botonicApiService, projectRoot, projectName, botName, configuration) {
+  console.log(
+    `
+\u{1F680} New bot "${botName}" detected \u2014 deploying before serve can start...
+`
+  );
+  await deployBotToHubtype(botonicApiService, projectRoot, projectName);
+  const botId = botonicApiService.bot?.id;
+  if (botId) {
+    try {
+      await botonicApiService.createWebchatIntegration(botId, botName);
+      console.log(`   \u{1F50C} Webchat integration created for bot "${botName}".`);
+    } catch {
+    }
+  }
+  botonicApiService.saveAllCredentials();
+  const resolvedConfig = configuration ?? "local";
+  console.log(
+    `
+\u2705 Bot "${botName}" deployed successfully.
+   Run the following command to start serving:
+
+   pnpm nx run ${projectName}:serve:${resolvedConfig} --botName="${botName}"
+`
+  );
+  throw new BotDeployedRestartRequired(botName, projectName);
+}
+class BotDeployedRestartRequired extends Error {
+  constructor(botName, projectName) {
+    super(
+      `Bot "${botName}" was just deployed. Run: pnpm nx serve ${projectName}`
+    );
+    this.name = "BotDeployedRestartRequired";
+  }
+}
+function isBotDeployedRestartRequired(error) {
+  return error instanceof Error && error.name === "BotDeployedRestartRequired";
+}
+function selectedBotHasActiveWhatsapp(botId) {
+  try {
+    const botsJsonPath = (0, import_path.join)((0, import_os.homedir)(), ".botonic", "bots.json");
+    if (!(0, import_fs.existsSync)(botsJsonPath)) return false;
+    const registry = JSON.parse((0, import_fs.readFileSync)(botsJsonPath, "utf8"));
+    const bot = Object.values(registry).flat().find((e) => e.id === botId);
+    return bot?.providers?.some((p) => p.provider === "whatsapp" && p.is_active) ?? false;
+  } catch {
+    return false;
+  }
+}
+const BOTONIC_BUNDLE_FILE = "botonic_bundle.zip";
+const BOTONIC_TEMP_DIRNAME = "tmp";
+async function createBundle(projectRoot) {
+  console.log("\u{1F4E6} Creating deployment bundle...");
+  if ((0, import_file_system.pathExists)((0, import_path.join)(projectRoot, BOTONIC_TEMP_DIRNAME))) {
+    (0, import_file_system.removeRecursively)((0, import_path.join)(projectRoot, BOTONIC_TEMP_DIRNAME));
+  }
+  const webchatHtmlPath = (0, import_path.join)(projectRoot, "dist", "webchat", "webchat.html");
+  const webchatIndexPath = (0, import_path.join)(projectRoot, "dist", "webchat", "index.html");
+  if ((0, import_file_system.pathExists)(webchatHtmlPath)) {
+    (0, import_fs.renameSync)(webchatHtmlPath, webchatIndexPath);
+  }
+  const webviewsHtmlPath = (0, import_path.join)(
+    projectRoot,
+    "dist",
+    "webviews",
+    "webviews.html"
+  );
+  const webviewsIndexPath = (0, import_path.join)(projectRoot, "dist", "webviews", "index.html");
+  if ((0, import_file_system.pathExists)(webviewsHtmlPath)) {
+    (0, import_fs.renameSync)(webviewsHtmlPath, webviewsIndexPath);
+  }
+  (0, import_file_system.createDir)((0, import_path.join)(projectRoot, BOTONIC_TEMP_DIRNAME));
+  (0, import_file_system.copy)(
+    (0, import_path.join)(projectRoot, "dist"),
+    (0, import_path.join)(projectRoot, BOTONIC_TEMP_DIRNAME, "dist")
+  );
+  const zipRes = await import_zip_a_folder.ZipAFolder.zip(
+    (0, import_path.join)(projectRoot, BOTONIC_TEMP_DIRNAME),
+    (0, import_path.join)(projectRoot, BOTONIC_BUNDLE_FILE)
+  );
+  if (zipRes instanceof Error) {
+    throw zipRes;
+  }
+  const zipStats = (0, import_fs.statSync)((0, import_path.join)(projectRoot, BOTONIC_BUNDLE_FILE));
+  console.log("\u2705 Bundle created successfully!");
+  if (zipStats.size >= 20 * 10 ** 6) {
+    throw new Error(
+      `Bundle too large: ${(zipStats.size / 1024 / 1024).toFixed(2)}MB (max: 20MB)`
+    );
+  }
+}
+async function deployBundle(botonicApiService, botConfigJson, projectRoot) {
+  console.log("\u{1F680} Deploying to Hubtype Cloud...");
+  try {
+    const deploy = await botonicApiService.deployBot(
+      (0, import_path.join)(projectRoot, BOTONIC_BUNDLE_FILE),
+      botConfigJson
+    );
+    if (deploy.response?.status === 403 || !deploy.data.deploy_id) {
+      throw new Error(
+        `Deploy Botonic Error: ${String(deploy.response?.data?.status)}`
+      );
+    }
+    console.log("\u23F3 Waiting for deployment to complete...");
+    while (true) {
+      await (0, import_system.sleep)(500);
+      const deployStatus = await botonicApiService.deployStatus(
+        deploy.data.deploy_id
+      );
+      if (deployStatus.data.is_completed) {
+        if (deployStatus.data.status === "deploy_status_completed_ok") {
+          console.log("\u2705 Deployment completed successfully!");
+          return { hasDeployErrors: false };
+        } else {
+          throw new Error(deployStatus.data.error);
+        }
+      }
+    }
+  } catch (error) {
+    console.error("\u274C Deployment failed");
+    let reason = String(error);
+    if (error.response?.data) {
+      reason = error.response.data.join("");
+    }
+    console.error(`${reason}`);
+    return { hasDeployErrors: true };
+  }
+}
+async function displayDeployResults(botonicApiService, { hasDeployErrors }) {
+  try {
+    const providersRes = await botonicApiService.getProviders();
+    const providers = providersRes.data.results ?? [];
+    if (hasDeployErrors) return false;
+    if (!providers.length) {
+      const botId = botonicApiService.botInfo().id;
+      const accessToken = botonicApiService.getOauth().access_token;
+      const links = `Now, you can integrate a channel in:
+https://app.hubtype.com/bots/${botId}/integrations?access_token=${accessToken}`;
+      console.log(links);
+    } else {
+      displayProviders(providers);
+    }
+    return true;
+  } catch (e) {
+    console.error(`   There was an error getting the providers: ${String(e)}`);
+    return false;
+  }
+}
+function displayProviders(providers) {
+  console.log("\u{1F389} DEPLOYMENT SUCCESSFUL!");
+  console.log("\u{1F680} Your bot is now live and ready to chat!");
+  console.log("\u{1F4F1} Your bot is published on:");
+  providers.forEach((p) => {
+    if (p.provider === "whatsapp")
+      console.log(`   \u{1F4AC}  [WhatsApp] https://wa.me/${p.username}`);
+    if (p.provider === "facebook")
+      console.log(`   \u{1F4AC}  [Facebook] https://m.me/${p.username}`);
+    if (p.provider === "telegram")
+      console.log(`   \u{1F4AC}  [Telegram] https://t.me/${p.username}`);
+    if (p.provider === "twitter")
+      console.log(`   \u{1F4AC}  [Twitter] https://t.me/${p.username}`);
+    if (p.provider === "generic")
+      console.log(`   \u{1F4AC}  [Generic] Your app or website`);
+  });
+}
+async function deployBotToHubtype(botonicApiService, projectRoot, projectName) {
+  console.log("\u{1F528} Preparing your bot for deployment...\n");
+  const buildOut = await botonicApiService.build({
+    projectRoot,
+    projectName
+  });
+  if (!buildOut) {
+    throw new Error("Build failed");
+  }
+  const botConfigJson = await import_bot_config.BotConfig.get(projectRoot);
+  await createBundle(projectRoot);
+  const { hasDeployErrors } = await deployBundle(
+    botonicApiService,
+    botConfigJson,
+    projectRoot
+  );
+  await displayDeployResults(botonicApiService, { hasDeployErrors });
+  (0, import_fs.rmSync)((0, import_path.join)(projectRoot, BOTONIC_BUNDLE_FILE));
+  (0, import_file_system.removeRecursively)((0, import_path.join)(projectRoot, BOTONIC_TEMP_DIRNAME));
+  botonicApiService.saveAllCredentials();
+  if (hasDeployErrors) {
+    throw new Error("Deployment failed. Check the output above for details.");
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   askEmailPassword,
   askLogin,
   askSignup,
   createNewBotWithName,
+  deployBotToHubtype,
+  ensureBot,
   ensureHubtypeLoginBeforeTunnel,
-  ensureLocalRuntimeBot,
-  ensureLocalRuntimeBotBeforeTunnel,
   findMatchingConfigurationKey,
+  getActiveTestWebchatProviderAppId,
+  getActiveWebchatProviderAppId,
   getAppIdFromEnvFile,
   getAppIdFromEnvFileForConfig,
   getAvailableBots,
   handleAuthentication,
   handleExecutorError,
+  isBotDeployedRestartRequired,
   logWorkingAsAndEnvironment,
   performDeployLocalRuntimeWithEndpoint,
-  removeAppBotonicJson,
   resolveHubtypeEnvironment,
   resolveProjectPath,
+  selectBotForServe,
+  selectedBotHasActiveWhatsapp,
   writeAppIdToEnvFile,
   writeAppIdToLocalEnv,
-  writeEnvVarToEnvFile,
-  writeLocalRuntimeBotToAppFolder
+  writeEnvVarToEnvFile
 });