@botonic/nx-plugin 2.23.0

package/src/executors/deploy-to-hubtype/executor.js

@@ -0,0 +1,308 @@
+"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_exports = {};
+__export(executor_exports, {
+  default: () => deployToHubtypeExecutor
+});
+module.exports = __toCommonJS(executor_exports);
+var import_enquirer = require("enquirer");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_zip_a_folder = require("zip-a-folder");
+var import_api_service = require("../../lib/api-service");
+var import_bot_config = require("../../lib/bot-config");
+var import_executor_helpers = require("../../lib/util/executor-helpers");
+var import_file_system = require("../../lib/util/file-system");
+var import_system = require("../../lib/util/system");
+const BOTONIC_BUNDLE_FILE = "botonic_bundle.zip";
+const BOTONIC_TEMP_DIRNAME = "tmp";
+let PROJECT_ROOT;
+async function deployToHubtypeExecutor(options, context) {
+  if (!context.projectName) {
+    throw new Error("Project name is not defined in executor context");
+  }
+  PROJECT_ROOT = (0, import_executor_helpers.resolveProjectPath)(context);
+  try {
+    const { targetEnvironment, environmentVariables } = (0, import_executor_helpers.resolveHubtypeEnvironment)(context, options);
+    const botonicApiService = new import_api_service.BotonicAPIService({
+      projectRoot: PROJECT_ROOT,
+      workspaceRoot: (0, import_path.resolve)(context.root),
+      environmentVariables,
+      targetEnvironment
+    });
+    const botName = options.botName;
+    if (!botonicApiService.oauth) {
+      if (options.email && options.password) {
+        await botonicApiService.login(options.email, options.password);
+        botonicApiService.saveAllCredentials();
+      } else {
+        await (0, import_executor_helpers.handleAuthentication)(botonicApiService);
+      }
+    }
+    await (0, import_executor_helpers.logWorkingAsAndEnvironment)(botonicApiService);
+    console.log(
+      `\u{1F680} Deploying to Hubtype... [${environmentVariables["VITE_HUBTYPE_API_URL"]}]
+`
+    );
+    if (botName) {
+      await handleBotFromFlag(
+        botonicApiService,
+        botName,
+        options.createIfNotExists
+      );
+    } else {
+      await handleBotFlow(botonicApiService);
+    }
+    await deploy(botonicApiService, PROJECT_ROOT, context.projectName);
+    return { success: true };
+  } catch (error) {
+    return (0, import_executor_helpers.handleExecutorError)(error, "Deployment");
+  }
+}
+async function handleBotFromFlag(botonicApiService, botName, createIfNotExists) {
+  const bots = await (0, import_executor_helpers.getAvailableBots)(botonicApiService);
+  const bot = bots.find((b) => b.name === botName);
+  if (bot) {
+    botonicApiService.setCurrentBot(bot);
+  } else {
+    if (createIfNotExists) {
+      console.log(
+        `\u{1F916} Bot "${botName}" doesn't exist. Creating it automatically...`
+      );
+      await createNewBot(botonicApiService, botName);
+    } else {
+      const response = await (0, import_enquirer.prompt)({
+        type: "confirm",
+        name: "create_bot_confirm",
+        message: `\u{1F916} Bot "${botName}" doesn't exist. Do you want to create it?`
+      });
+      if (response.create_bot_confirm) {
+        await createNewBot(botonicApiService, botName);
+      } else {
+        throw new Error(`Bot "${botName}" not found`);
+      }
+    }
+  }
+}
+async function handleBotFlow(botonicApiService) {
+  if (!botonicApiService.bot || !Object.keys(botonicApiService.bot).length) {
+    await newBotFlow(botonicApiService);
+  } else {
+    const resp = await botonicApiService.getBots();
+    const bots = resp.data.results;
+    const firstId = botonicApiService.bot.id;
+    bots.sort(
+      (x, y) => x.id === firstId ? -1 : y.id === firstId ? 1 : 0
+    );
+    await selectExistentBot(botonicApiService, bots);
+  }
+}
+async function newBotFlow(botonicApiService) {
+  const bots = await (0, import_executor_helpers.getAvailableBots)(botonicApiService);
+  if (!bots.length) {
+    await createNewBot(botonicApiService);
+  } else {
+    const response = await (0, import_enquirer.prompt)({
+      type: "confirm",
+      name: "create_bot_confirm",
+      message: "\u{1F916} Do you want to create a new bot?"
+    });
+    if (response.create_bot_confirm) {
+      await createNewBot(botonicApiService);
+    } else {
+      await selectExistentBot(botonicApiService, bots);
+    }
+  }
+}
+async function createNewBot(botonicApiService, botName) {
+  if (botName) {
+    await (0, import_executor_helpers.createNewBotWithName)(botonicApiService, botName);
+  } else {
+    console.log("\u{1F916} Let's create a new bot!\n");
+    const response = await (0, import_enquirer.prompt)({
+      type: "input",
+      name: "bot_name",
+      message: "\u{1F916} Bot name:",
+      validate: (input) => {
+        return input.length > 0 ? true : "Bot name cannot be empty";
+      }
+    });
+    await (0, import_executor_helpers.createNewBotWithName)(botonicApiService, response.bot_name);
+  }
+}
+async function selectExistentBot(botonicApiService, bots) {
+  console.log("\u{1F4CB} Select a bot to deploy:\n");
+  const providersPromises = bots.map((b) => botonicApiService.getProviders(b.id));
+  const providers = await Promise.all(providersPromises);
+  const botsWithProviders = bots.map((bot2, index) => ({
+    ...bot2,
+    providers: providers[index].data.results
+  }));
+  const response = await (0, import_enquirer.prompt)({
+    type: "select",
+    name: "bot_name",
+    message: "\u{1F916} Please select a bot:",
+    choices: botsWithProviders.map((bot2) => {
+      return {
+        name: bot2.name,
+        message: bot2.name
+      };
+    })
+  });
+  const selectedBotName = response.bot_name;
+  const bot = botsWithProviders.find((bot2) => bot2.name === selectedBotName);
+  if (bot) {
+    botonicApiService.setCurrentBot(bot);
+    console.log(`\u2705 Selected bot: ${bot.name}`);
+  }
+}
+async function deploy(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
+  );
+  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();
+}
+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) {
+  console.log("\u{1F680} Deploying to Hubtype Cloud...");
+  try {
+    const deploy2 = await botonicApiService.deployBot(
+      (0, import_path.join)(PROJECT_ROOT, BOTONIC_BUNDLE_FILE),
+      botConfigJson
+    );
+    if (deploy2.response?.status === 403 || !deploy2.data.deploy_id) {
+      throw new Error(
+        `Deploy Botonic Error: ${String(deploy2.response?.data?.status)}`
+      );
+    }
+    console.log("\u23F3 Waiting for deployment to complete...");
+    while (true) {
+      await (0, import_system.sleep)(500);
+      const deployStatus = await botonicApiService.deployStatus(
+        deploy2.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`);
+  });
+}

package/src/executors/deploy-to-hubtype/schema.d.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 schema_d_exports = {};
+module.exports = __toCommonJS(schema_d_exports);

package/src/executors/deploy-to-hubtype/schema.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "DeployToHubtypeExecutor",
+  "title": "Deploy to Hubtype executor",
+  "type": "object",
+  "properties": {
+    "configuration": {
+      "type": "string",
+      "enum": ["local", "dev", "dev2", "qa", "prod"],
+      "description": "Environment to deploy to"
+    },
+    "botName": {
+      "type": "string",
+      "description": "Name of the bot from Hubtype where you want to deploy"
+    },
+    "email": {
+      "type": "string",
+      "description": "Email from Hubtype Organization"
+    },
+    "password": {
+      "type": "string",
+      "description": "Password from Hubtype Organization"
+    },
+    "createIfNotExists": {
+      "type": "boolean",
+      "description": "Automatically create the bot if it doesn't exist (non-interactive mode for CI)",
+      "default": false
+    }
+  },
+  "additionalProperties": true
+}

package/src/executors/e2e-webchat/botonic-package-publish.spec.ts

@@ -0,0 +1,84 @@
+import { expect, test } from 'playwright/test'
+
+test.describe('Botonic Publish E2E', () => {
+  test.beforeEach(async ({ page }) => {
+    page.on('console', msg => {
+      if (msg.type() === 'error') {
+        console.log(`[BROWSER ERROR] ${msg.text()}`)
+      }
+    })
+
+    page.on('pageerror', error => {
+      console.log(`[PAGE ERROR] ${error.message}`)
+    })
+
+    await page.goto('/')
+    await page.waitForLoadState('networkidle')
+    await page.waitForSelector('button[class*="webchat-trigger"]', {
+      timeout: 3000,
+    })
+  })
+
+  async function ensureWebchatOpen(page: any) {
+    const trigger = page.locator('button[class*="webchat-trigger"]').first()
+    await expect(trigger).toBeVisible({ timeout: 10000 })
+
+    const ariaExpanded = await trigger.getAttribute('aria-expanded')
+    if (ariaExpanded === 'false') {
+      await trigger.click()
+      await page.waitForTimeout(300)
+    }
+
+    const container = page
+      .locator('[class*="webchat-container-module"]')
+      .first()
+    await expect(container).toBeVisible({ timeout: 5000 })
+
+    return { trigger, container }
+  }
+
+  test('webchat trigger renders and opens webchat', async ({ page }) => {
+    const trigger = page.locator('button[class*="webchat-trigger"]').first()
+    await expect(trigger).toBeVisible({ timeout: 10000 })
+
+    const ariaExpanded = await trigger.getAttribute('aria-expanded')
+    if (ariaExpanded === 'false') {
+      await trigger.click()
+      await page.waitForTimeout(300)
+    }
+
+    const container = page
+      .locator('[class*="webchat-container-module"]')
+      .first()
+    await expect(container).toBeVisible({ timeout: 5000 })
+  })
+
+  test('bot responds to user message', async ({ page }) => {
+    await ensureWebchatOpen(page)
+
+    const input = page.locator('textarea').first()
+    await expect(input).toBeVisible({ timeout: 5000 })
+
+    await input.fill('hello')
+    await input.press('Enter')
+
+    const messages = page.locator('[class*="message-module"]')
+    await expect(messages.first()).toBeVisible({ timeout: 15000 })
+  })
+
+  test('send button works', async ({ page }) => {
+    await ensureWebchatOpen(page)
+
+    const input = page.locator('textarea').first()
+    const sendButton = page.locator('button[class*="send-button"]').first()
+
+    await expect(input).toBeVisible({ timeout: 5000 })
+    await expect(sendButton).toBeVisible()
+
+    await input.fill('test message')
+    await sendButton.click()
+
+    const messages = page.locator('[class*="message-module"]')
+    await expect(messages.first()).toBeVisible({ timeout: 15000 })
+  })
+})

package/src/executors/e2e-webchat/executor.d.ts

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

package/src/executors/e2e-webchat/executor.js

@@ -0,0 +1,134 @@
+"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_exports = {};
+__export(executor_exports, {
+  default: () => e2eExecutor
+});
+module.exports = __toCommonJS(executor_exports);
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_path = require("path");
+var import_executor = __toESM(require("../deploy-netlify-snapshot/executor"));
+const WEBCHAT_OUTPUT_DIR = "dist/webchat";
+async function e2eExecutor(options, context) {
+  const projectRoot = context.projectsConfigurations?.projects[context.projectName ?? ""]?.root ?? "";
+  if (!options.dir) {
+    console.log("\u{1F528} Step 1/3: Building webchat app...");
+    try {
+      (0, import_child_process.execSync)(`npx nx build-webchat-app ${context.projectName}`, {
+        stdio: "inherit",
+        cwd: context.root
+      });
+    } catch {
+      console.error("\u274C Webchat build failed \u2014 aborting e2e tests");
+      return { success: false };
+    }
+  }
+  const dir = options.dir ? (0, import_path.resolve)(context.root, projectRoot, options.dir) : (0, import_path.resolve)(context.root, projectRoot, WEBCHAT_OUTPUT_DIR);
+  const deployStep = options.dir ? "1/2" : "2/3";
+  const playwrightStep = options.dir ? "2/2" : "3/3";
+  console.log(`
+\u{1F4E6} Step ${deployStep}: Deploying snapshot to Netlify...`);
+  const deployResult = await (0, import_executor.default)(
+    {
+      dir,
+      siteId: options.siteId,
+      authToken: options.authToken,
+      alias: options.alias || `e2e-${Date.now()}`,
+      prod: options.prod
+    },
+    context
+  );
+  if (!deployResult.success || !deployResult.deployUrl) {
+    console.error("\u274C Netlify deploy failed \u2014 aborting e2e tests");
+    return { success: false };
+  }
+  const snapshotUrl = deployResult.deployUrl;
+  const e2eTmpDir = (0, import_path.resolve)(context.root, ".botonic-e2e-tmp");
+  (0, import_fs.mkdirSync)(e2eTmpDir, { recursive: true });
+  const e2eConfigPath = (0, import_path.resolve)(e2eTmpDir, "playwright.config.js");
+  (0, import_fs.writeFileSync)(
+    e2eConfigPath,
+    `module.exports = {
+  testDir: '.',
+  testMatch: '*.spec.ts',
+  timeout: 30000,
+  retries: 1,
+  use: {
+    baseURL: process.env.WEBCHAT_URL || 'http://localhost:8080',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'on-first-retry',
+  },
+  reporter: [['html', { outputFolder: 'playwright-report' }], ['list']],
+};
+`
+  );
+  const bundledSpecPath = (0, import_path.resolve)(__dirname, "botonic-package-publish.spec.ts");
+  const specDestPath = (0, import_path.resolve)(e2eTmpDir, "botonic-package-publish.spec.ts");
+  if ((0, import_fs.existsSync)(bundledSpecPath)) {
+    (0, import_fs.copyFileSync)(bundledSpecPath, specDestPath);
+  } else if (options.configPath) {
+    const customConfigPath = (0, import_path.resolve)(context.root, options.configPath);
+    console.log(
+      `
+\u{1F3AD} Step ${playwrightStep}: Running Playwright tests against ${snapshotUrl}`
+    );
+    try {
+      (0, import_child_process.execSync)(`npx playwright test --config="${customConfigPath}"`, {
+        env: { ...process.env, WEBCHAT_URL: snapshotUrl },
+        stdio: "inherit",
+        cwd: context.root
+      });
+      console.log("\u2705 E2E tests passed!");
+      return { success: true };
+    } catch {
+      console.error("\u274C E2E tests failed");
+      return { success: false };
+    }
+  }
+  console.log(
+    `
+\u{1F3AD} Step ${playwrightStep}: Running Playwright tests against ${snapshotUrl}`
+  );
+  console.log(`   Config: ${e2eConfigPath}`);
+  console.log(`   Tests dir: ${e2eTmpDir}`);
+  try {
+    (0, import_child_process.execSync)(`npx playwright test --config="${e2eConfigPath}"`, {
+      env: { ...process.env, WEBCHAT_URL: snapshotUrl },
+      stdio: "inherit",
+      cwd: context.root
+    });
+    console.log("\u2705 E2E tests passed!");
+    return { success: true };
+  } catch {
+    console.error("\u274C E2E tests failed");
+    return { success: false };
+  }
+}

package/src/executors/e2e-webchat/schema.d.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 schema_d_exports = {};
+module.exports = __toCommonJS(schema_d_exports);

package/src/executors/e2e-webchat/schema.json

@@ -0,0 +1,35 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "E2EExecutor",
+  "title": "Botonic E2E executor",
+  "type": "object",
+  "properties": {
+    "dir": {
+      "type": "string",
+      "description": "Directory of static files to deploy. If omitted, builds the webchat app first and uses dist/webchat"
+    },
+    "siteId": {
+      "type": "string",
+      "description": "Netlify site API ID. Falls back to BOTONIC_E2E_NETLIFY_SITE_ID env var"
+    },
+    "authToken": {
+      "type": "string",
+      "description": "Netlify personal access token. Falls back to NETLIFY_AUTH_TOKEN env var"
+    },
+    "alias": {
+      "type": "string",
+      "description": "Deploy alias for a unique snapshot URL. Defaults to a timestamp"
+    },
+    "prod": {
+      "type": "boolean",
+      "description": "Deploy to production Netlify URL instead of a preview",
+      "default": false
+    },
+    "configPath": {
+      "type": "string",
+      "description": "Path to a custom Playwright config file. Defaults to the built-in botonic webchat config"
+    }
+  },
+  "required": [],
+  "additionalProperties": false
+}

package/src/executors/integrate-provider/executor.d.ts

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