@botonic/nx-plugin 2.23.0

package/src/lib/util/executor-helpers.d.ts

@@ -0,0 +1,97 @@
+import type { ExecutorContext } from '@nx/devkit';
+import { BotonicAPIService } from '../api-service';
+import type { BotDetail } from '../interfaces';
+export declare function resolveProjectPath(context: ExecutorContext): string;
+export declare function askEmailPassword(): Promise<{
+    email: string;
+    password: string;
+}>;
+export declare function askLogin(botonicApiService: BotonicAPIService): Promise<void>;
+export declare function askSignup(botonicApiService: BotonicAPIService): Promise<void>;
+export declare function handleAuthentication(botonicApiService: BotonicAPIService): Promise<void>;
+/**
+ * Logs "Working as {user} in environment '{env}' [url]" as the first line for executors that need auth.
+ * Call after ensuring login (so service.oauth is set). No-op if not logged in.
+ */
+export declare function logWorkingAsAndEnvironment(botonicApiService: BotonicAPIService): Promise<void>;
+export declare function getAvailableBots(botonicApiService: BotonicAPIService): Promise<any[]>;
+export declare function createNewBotWithName(botonicApiService: BotonicAPIService, botName: string): Promise<void>;
+export declare function getAppIdFromEnvFile(projectRoot: string, appIdKey: string): string | null;
+/**
+ * Reads VITE_HUBTYPE_APP_ID from .env.[configuration] (e.g. .env.dev) or .env.local when configuration is 'local'.
+ * Use this after deploy: deploy writes to .env.[configuration], so read from there instead of .env.local to avoid overwriting with a stale value.
+ */
+export declare function getAppIdFromEnvFileForConfig(projectRoot: string, configuration: (typeof TARGET_ENV_NAMES)[number], appIdKey?: string): string | null;
+export declare function writeAppIdToLocalEnv(projectRoot: string, appId: string, appIdKey?: string): Promise<void>;
+declare const TARGET_ENV_NAMES: readonly ["local", "dev", "dev2", "qa", "prod"];
+/**
+ * Writes or updates VITE_HUBTYPE_APP_ID in .env.[targetEnv] so that when
+ * serving with that configuration (e.g. MODE=dev), Vite loads the correct APP_ID.
+ * For targetEnv === 'local' delegates to writeAppIdToLocalEnv.
+ */
+export declare function writeAppIdToEnvFile(projectRoot: string, appId: string, targetEnv: (typeof TARGET_ENV_NAMES)[number], appIdKey?: string): Promise<void>;
+/**
+ * Writes or updates a single env var (key=value) in .env.[targetEnv].
+ * Used e.g. for VITE_HUBTYPE_BOT_ID so the webchat auth URL uses the correct bot.
+ */
+export declare function writeEnvVarToEnvFile(projectRoot: string, key: string, value: string, targetEnv: (typeof TARGET_ENV_NAMES)[number]): void;
+export declare function handleExecutorError(error: any, operation: string, showHelp?: boolean): {
+    success: false;
+    reason: string;
+};
+/**
+ * Finds the configuration key that matches the given environment object
+ * @param configurations - The configurations object with env properties
+ * @param targetEnv - The environment object to match against
+ * @returns The configuration key if found, null otherwise
+ */
+export declare function findMatchingConfigurationKey(configurations: Record<string, {
+    env?: Record<string, any>;
+}>, targetEnv: Record<string, any>): string;
+export declare function resolveHubtypeEnvironment(context: ExecutorContext, options: any): {
+    targetEnvironment: string;
+    environmentVariables: Record<string, any>;
+};
+/**
+ * Ensures the user is logged in to Hubtype before starting the tunnel flow.
+ * Run this before Lambda + cloudflared + deploy_local_runtime so the login prompt happens first.
+ */
+export declare function ensureHubtypeLoginBeforeTunnel(context: ExecutorContext, projectRoot: string, options?: PerformDeployLocalRuntimeOptions): Promise<void>;
+/**
+ * Ensures a local runtime bot is selected or created and persisted to .botonic.json.
+ * Call this after ensureHubtypeLoginBeforeTunnel and before starting the tunnel, so bot detection runs after login but before tunnel setup.
+ * Does not log "Working as..." (already logged by ensureHubtypeLoginBeforeTunnel).
+ */
+export declare function ensureLocalRuntimeBotBeforeTunnel(context: ExecutorContext, projectRoot: string, options?: PerformDeployLocalRuntimeOptions): Promise<void>;
+/**
+ * Writes the local runtime bot to .botonic.json in the app folder so the created bot is persisted per project.
+ */
+export declare function writeLocalRuntimeBotToAppFolder(projectRoot: string, bot: BotDetail): void;
+/**
+ * Removes the app folder .botonic.json so the next run will prompt to create/select a new bot (e.g. after 404 when bot was deleted).
+ */
+export declare function removeAppBotonicJson(projectRoot: string): void;
+/**
+ * Ensures a local runtime bot is set: reuses one from .botonic.json, or prompts to select an existing bot or create a new one by name.
+ * Used when performing deploy_local_runtime with a tunnel URL from serve-bot or serve-dev-tunnel target.
+ */
+export declare function ensureLocalRuntimeBot(botonicApiService: BotonicAPIService): Promise<void>;
+export interface PerformDeployLocalRuntimeOptions {
+    email?: string;
+    password?: string;
+    env?: Record<string, unknown>;
+    /** Explicit configuration name (e.g. 'dev') so deploy uses the right environment when Nx does not merge config. */
+    configuration?: string;
+}
+export interface PerformDeployLocalRuntimeResult {
+    botId: string;
+    targetEnvironment: string;
+    environmentVariables: Record<string, unknown>;
+}
+/**
+ * Performs deploy_local_runtime with the given endpoint (e.g. tunnel URL).
+ * Handles auth, bot creation/selection, and deploy. Returns the bot id and env for later cleanup (e.g. deleteBot on shutdown).
+ * Used by serve-bot (tunnel is always on).
+ */
+export declare function performDeployLocalRuntimeWithEndpoint(context: ExecutorContext, projectRoot: string, endpoint: string, options?: PerformDeployLocalRuntimeOptions): Promise<PerformDeployLocalRuntimeResult>;
+export {};

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

@@ -0,0 +1,574 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var executor_helpers_exports = {};
+__export(executor_helpers_exports, {
+  askEmailPassword: () => askEmailPassword,
+  askLogin: () => askLogin,
+  askSignup: () => askSignup,
+  createNewBotWithName: () => createNewBotWithName,
+  ensureHubtypeLoginBeforeTunnel: () => ensureHubtypeLoginBeforeTunnel,
+  ensureLocalRuntimeBot: () => ensureLocalRuntimeBot,
+  ensureLocalRuntimeBotBeforeTunnel: () => ensureLocalRuntimeBotBeforeTunnel,
+  findMatchingConfigurationKey: () => findMatchingConfigurationKey,
+  getAppIdFromEnvFile: () => getAppIdFromEnvFile,
+  getAppIdFromEnvFileForConfig: () => getAppIdFromEnvFileForConfig,
+  getAvailableBots: () => getAvailableBots,
+  handleAuthentication: () => handleAuthentication,
+  handleExecutorError: () => handleExecutorError,
+  logWorkingAsAndEnvironment: () => logWorkingAsAndEnvironment,
+  performDeployLocalRuntimeWithEndpoint: () => performDeployLocalRuntimeWithEndpoint,
+  removeAppBotonicJson: () => removeAppBotonicJson,
+  resolveHubtypeEnvironment: () => resolveHubtypeEnvironment,
+  resolveProjectPath: () => resolveProjectPath,
+  writeAppIdToEnvFile: () => writeAppIdToEnvFile,
+  writeAppIdToLocalEnv: () => writeAppIdToLocalEnv,
+  writeEnvVarToEnvFile: () => writeEnvVarToEnvFile,
+  writeLocalRuntimeBotToAppFolder: () => writeLocalRuntimeBotToAppFolder
+});
+module.exports = __toCommonJS(executor_helpers_exports);
+var import_enquirer = require("enquirer");
+var import_fs = require("fs");
+var import_path = require("path");
+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");
+function resolveProjectPath(context) {
+  if (!context.projectName) {
+    throw new Error("Project name is not defined in executor context");
+  }
+  const projectConfig = context.projectsConfigurations.projects[context.projectName];
+  if (!projectConfig) {
+    throw new Error(
+      `Project configuration not found for project: ${context.projectName}`
+    );
+  }
+  const projectRoot = projectConfig.root || `apps/${context.projectName}`;
+  return (0, import_path.join)(context.root, projectRoot);
+}
+async function askEmailPassword() {
+  console.log("\n\u{1F4DD} Please provide your Hubtype credentials:\n");
+  const emailResponse = await (0, import_enquirer.prompt)({
+    type: "input",
+    name: "email",
+    message: "\u{1F4E7} Email:",
+    validate: (input) => {
+      const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+      return emailRegex.test(input) ? true : "Please enter a valid email address";
+    }
+  });
+  const passwordResponse = await (0, import_enquirer.prompt)({
+    type: "password",
+    name: "password",
+    message: "\u{1F511} Password:",
+    validate: (input) => {
+      return input.length > 0 ? true : "Password cannot be empty";
+    }
+  });
+  return {
+    email: emailResponse.email,
+    password: passwordResponse.password
+  };
+}
+async function askLogin(botonicApiService) {
+  const credentials = await askEmailPassword();
+  console.log("\u{1F510} Authenticating with Hubtype...");
+  await botonicApiService.login(credentials.email, credentials.password);
+  botonicApiService.saveAllCredentials();
+  console.log("\u2705 Authentication successful!");
+}
+async function askSignup(botonicApiService) {
+  const credentials = await askEmailPassword();
+  console.log("\u{1F4DD} Creating your account...");
+  const orgName = credentials.email.split("@")[0];
+  const campaign = { product: "botonic" };
+  await botonicApiService.signup(
+    credentials.email,
+    credentials.password,
+    orgName,
+    campaign
+  );
+  console.log("\u2705 Account created successfully!");
+  await botonicApiService.login(credentials.email, credentials.password);
+  botonicApiService.saveAllCredentials();
+}
+async function handleAuthentication(botonicApiService) {
+  const response = await (0, import_enquirer.prompt)({
+    type: "select",
+    name: "signupConfirmation",
+    message: "\n\u{1F510} You need to login before proceeding.\nDo you have a Hubtype account already?\n",
+    choices: [
+      { name: "signup", message: "No, I need to create a new one (Signup)" },
+      { name: "login", message: "Yes, I do. (Login)" }
+    ]
+  });
+  if (response.signupConfirmation === "login") {
+    await askLogin(botonicApiService);
+  } else {
+    await askSignup(botonicApiService);
+  }
+}
+async function logWorkingAsAndEnvironment(botonicApiService) {
+  if (!botonicApiService.oauth) return;
+  await botonicApiService.ensureMeLoaded();
+  const name = botonicApiService.getDisplayName();
+  const env = botonicApiService.targetEnvironment ?? "local";
+  const url = botonicApiService.baseUrl ?? "";
+  console.log(`Working as ${name} in environment '${env}' [${url}]
+`);
+}
+async function getAvailableBots(botonicApiService) {
+  const resp = await botonicApiService.getBots();
+  return resp.data.results;
+}
+const MAX_BOT_NAME_LENGTH = 25;
+async function createNewBotWithName(botonicApiService, botName) {
+  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);
+  console.log(`\u2705 Bot "${botName}" created successfully!`);
+}
+function getAppIdFromEnvFile(projectRoot, appIdKey) {
+  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");
+    for (const line of lines) {
+      if (line.startsWith(`${appIdKey}=`)) {
+        return line.split("=")[1]?.trim();
+      }
+    }
+    return null;
+  } catch (error) {
+    console.warn(`\u26A0\uFE0F  Could not read .env.local file: ${error.message}`);
+    return null;
+  }
+}
+function getAppIdFromEnvFileForConfig(projectRoot, configuration, appIdKey = APP_ID_KEY) {
+  const fileName = configuration === "local" ? ".env.local" : `.env.${configuration}`;
+  const envFilePath = (0, import_path.join)(projectRoot, fileName);
+  if (!(0, import_fs.existsSync)(envFilePath)) {
+    return null;
+  }
+  try {
+    const envContent = (0, import_fs.readFileSync)(envFilePath, "utf8");
+    const lines = envContent.split("\n");
+    for (const line of lines) {
+      if (line.startsWith(`${appIdKey}=`)) {
+        return line.split("=")[1]?.trim();
+      }
+    }
+    return null;
+  } catch (error) {
+    console.warn(
+      `\u26A0\uFE0F  Could not read ${fileName}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return null;
+  }
+}
+async function writeAppIdToLocalEnv(projectRoot, appId, appIdKey = "VITE_HUBTYPE_APP_ID") {
+  const localEnvPath = (0, import_path.join)(projectRoot, ".env.local");
+  if (!(0, import_fs.existsSync)(localEnvPath)) {
+    (0, import_fs.writeFileSync)(localEnvPath, `${appIdKey}=${appId}
+`, "utf8");
+    console.log(`\u2705 Created .env.local with ${appIdKey}`);
+    return;
+  }
+  try {
+    const existingContent = (0, import_fs.readFileSync)(localEnvPath, "utf8");
+    const lines = existingContent.split("\n");
+    let updatedContent = existingContent;
+    const appIdLineIndex = lines.findIndex(
+      (line) => line.startsWith(`${appIdKey}=`)
+    );
+    if (appIdLineIndex !== -1) {
+      lines[appIdLineIndex] = `${appIdKey}=${appId}`;
+      updatedContent = lines.join("\n");
+    } else {
+      updatedContent = existingContent + `
+${appIdKey}=${appId}
+`;
+    }
+    (0, import_fs.writeFileSync)(localEnvPath, updatedContent, "utf8");
+    console.log(
+      `\u2705 ${appIdKey} has been automatically added to .env.local file!`
+    );
+    console.log(`\u{1F4DD} APP ID: ${appId}`);
+  } catch (error) {
+    console.error(
+      `\u274C Failed to write APP ID to .env.local file:`,
+      String(error)
+    );
+    console.log("\u{1F4CB} Please manually add this line to your .env.local file:");
+    console.log(`${appIdKey}=${appId}`);
+  }
+}
+const APP_ID_KEY = "VITE_HUBTYPE_APP_ID";
+const TARGET_ENV_NAMES = ["local", "dev", "dev2", "qa", "prod"];
+async function writeAppIdToEnvFile(projectRoot, appId, targetEnv, appIdKey = APP_ID_KEY) {
+  if (targetEnv === "local") {
+    await writeAppIdToLocalEnv(projectRoot, appId, appIdKey);
+    return;
+  }
+  const envFilePath = (0, import_path.join)(projectRoot, `.env.${targetEnv}`);
+  let content;
+  try {
+    content = (0, import_fs.existsSync)(envFilePath) ? (0, import_fs.readFileSync)(envFilePath, "utf8") : "";
+  } catch (error) {
+    console.warn(
+      `\u26A0\uFE0F  Could not read .env.${targetEnv}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return;
+  }
+  const lines = content.split("\n");
+  const lineIndex = lines.findIndex((line) => line.startsWith(`${appIdKey}=`));
+  if (lineIndex !== -1) {
+    lines[lineIndex] = `${appIdKey}=${appId}`;
+  } else {
+    lines.push(`${appIdKey}=${appId}`);
+  }
+  try {
+    (0, import_fs.writeFileSync)(envFilePath, lines.join("\n"), "utf8");
+    console.log(
+      `\u2705 ${appIdKey} updated in .env.${targetEnv} (${appId.slice(0, 8)}\u2026)`
+    );
+  } catch (error) {
+    console.warn(
+      `\u26A0\uFE0F  Could not write .env.${targetEnv}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function writeEnvVarToEnvFile(projectRoot, key, value, targetEnv) {
+  const fileName = targetEnv === "local" ? ".env.local" : `.env.${targetEnv}`;
+  const envFilePath = (0, import_path.join)(projectRoot, fileName);
+  let content;
+  try {
+    content = (0, import_fs.existsSync)(envFilePath) ? (0, import_fs.readFileSync)(envFilePath, "utf8") : "";
+  } catch (error) {
+    console.warn(
+      `\u26A0\uFE0F  Could not read ${fileName}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return;
+  }
+  const lines = content.split("\n");
+  const lineIndex = lines.findIndex((line) => line.startsWith(`${key}=`));
+  if (lineIndex !== -1) {
+    lines[lineIndex] = `${key}=${value}`;
+  } else {
+    lines.push(`${key}=${value}`);
+  }
+  try {
+    (0, import_fs.writeFileSync)(envFilePath, lines.join("\n"), "utf8");
+    console.log(`\u2705 ${key} updated in ${fileName} (${value.slice(0, 8)}\u2026)`);
+  } catch (error) {
+    console.warn(
+      `\u26A0\uFE0F  Could not write ${fileName}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function handleExecutorError(error, operation, showHelp = true) {
+  console.error(`\u274C ${operation} failed`);
+  let reason = "Unknown error";
+  if (error.response?.data) {
+    if (error.response?.data?.error_description) {
+      reason = error.response.data.error_description;
+    } else if (Array.isArray(error.response.data)) {
+      reason = error.response.data.join("");
+    } else {
+      reason = JSON.stringify(error.response.data);
+    }
+  } else if (error.message) {
+    reason = error.message;
+  } else {
+    reason = "An unexpected error occurred. Please try again.";
+  }
+  console.error(`   ${reason}`);
+  if (showHelp) {
+    console.error("\n\u{1F4A1} Need help? Check your configuration and try again.");
+    console.error("\u{1F517} Visit https://botonic.io for support");
+  }
+  return { success: false, reason };
+}
+function findMatchingConfigurationKey(configurations, targetEnv) {
+  if (!targetEnv) {
+    return "local";
+  }
+  for (const [key, config] of Object.entries(configurations)) {
+    if (!config.env) {
+      continue;
+    }
+    if (areObjectsEqual(config.env, targetEnv)) {
+      return key;
+    }
+  }
+  return "local";
+}
+function areObjectsEqual(obj1, obj2) {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function resolveHubtypeEnvironment(context, options) {
+  const explicitConfig = options.configuration && TARGET_ENV_NAMES.includes(
+    options.configuration
+  ) ? options.configuration : null;
+  const targetEnvironment = explicitConfig ? explicitConfig : findMatchingConfigurationKey(
+    context.target?.configurations || {},
+    options.env
+  );
+  const envFromTargetConfig = context.target?.configurations?.[targetEnvironment]?.env;
+  const environmentVariables = options.env || envFromTargetConfig || {
+    VITE_HUBTYPE_CLIENT_ID: process.env["VITE_HUBTYPE_CLIENT_ID"],
+    VITE_HUBTYPE_API_URL: process.env["VITE_HUBTYPE_API_URL"],
+    VITE_HUBTYPE_APP_ID: process.env["VITE_HUBTYPE_APP_ID"],
+    VITE_PUSHER_API_PREFIX: process.env["VITE_PUSHER_API_PREFIX"]
+  };
+  return {
+    targetEnvironment,
+    environmentVariables
+  };
+}
+async function ensureHubtypeLoginBeforeTunnel(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 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 ensureLocalRuntimeBot(botonicApiService) {
+  if (botonicApiService.hasLocalRuntimeBot()) {
+    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");
+    const response2 = 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;
+      }
+    });
+    const name = response2.bot_name.trim();
+    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 response = await (0, import_enquirer.prompt)({
+    type: "select",
+    name: "bot_id",
+    message: "\u{1F916} Select a bot or create new:",
+    choices: [
+      ...bots.map((bot2) => ({
+        name: bot2.id,
+        message: bot2.name
+      })),
+      { name: CREATE_NEW_CHOICE, message: "+ Create new bot" }
+    ]
+  });
+  if (response.bot_id === CREATE_NEW_CHOICE) {
+    const nameResponse = await (0, import_enquirer.prompt)({
+      type: "input",
+      name: "bot_name",
+      message: "\u{1F916} New 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;
+      }
+    });
+    const name = nameResponse.bot_name.trim();
+    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 {
+    throw new Error("Bot selection failed");
+  }
+}
+async function performDeployLocalRuntimeWithEndpoint(context, projectRoot, endpoint, 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);
+    }
+  }
+  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);
+      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";
+      if (appId) {
+        await writeAppIdToEnvFile(projectRoot, appId, resolvedTargetEnv);
+      }
+      botonicApiService.saveAllCredentials();
+      const botId = botonicApiService.botInfo().id;
+      writeEnvVarToEnvFile(
+        projectRoot,
+        "VITE_HUBTYPE_BOT_ID",
+        botId,
+        resolvedTargetEnv
+      );
+      return {
+        botId,
+        targetEnvironment,
+        environmentVariables
+      };
+    } catch (err) {
+      lastError = err;
+      const status = err?.response?.status;
+      if (status === 404 && attempt < maxAttempts) {
+        removeAppBotonicJson(projectRoot);
+        botonicApiService.setLocalRuntimeBot(null);
+        continue;
+      }
+      throw err;
+    }
+  }
+  throw lastError;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  askEmailPassword,
+  askLogin,
+  askSignup,
+  createNewBotWithName,
+  ensureHubtypeLoginBeforeTunnel,
+  ensureLocalRuntimeBot,
+  ensureLocalRuntimeBotBeforeTunnel,
+  findMatchingConfigurationKey,
+  getAppIdFromEnvFile,
+  getAppIdFromEnvFileForConfig,
+  getAvailableBots,
+  handleAuthentication,
+  handleExecutorError,
+  logWorkingAsAndEnvironment,
+  performDeployLocalRuntimeWithEndpoint,
+  removeAppBotonicJson,
+  resolveHubtypeEnvironment,
+  resolveProjectPath,
+  writeAppIdToEnvFile,
+  writeAppIdToLocalEnv,
+  writeEnvVarToEnvFile,
+  writeLocalRuntimeBotToAppFolder
+});

package/src/lib/util/file-system.d.ts

@@ -0,0 +1,8 @@
+import type { JSONObject } from '../interfaces';
+export declare function pathExists(path: string): boolean;
+export declare function readJSON(path: string): JSONObject | undefined;
+export declare function writeJSON(path: string, object: any): void;
+export declare function createDir(path: string): void;
+export declare function getHomeDirectory(): string;
+export declare function copy(from: string, to: string): void;
+export declare function removeRecursively(path: string): void;