@botonic/nx-plugin 2.23.0

package/src/migrations/utils/migration-utils.js

@@ -0,0 +1,448 @@
+"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 migration_utils_exports = {};
+__export(migration_utils_exports, {
+  createBotonicMigrationConfig: () => createBotonicMigrationConfig,
+  createFileProcessor: () => createFileProcessor,
+  findBotApps: () => findBotApps,
+  getCurrentBotonicCoreVersion: () => getCurrentBotonicCoreVersion,
+  getMigrationTargetVersion: () => getMigrationTargetVersion,
+  getPluginVersion: () => getPluginVersion,
+  runBotonicMigration: () => runBotonicMigration,
+  selectBotProjectsForMigration: () => selectBotProjectsForMigration,
+  updateBotonicDependencies: () => updateBotonicDependencies
+});
+module.exports = __toCommonJS(migration_utils_exports);
+var import_devkit = require("@nx/devkit");
+var import_enquirer = require("enquirer");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function updateBotonicDependencies(tree, targetVersion, projectPath) {
+  const exactVersion = targetVersion.replace(/^[\^~]/, "");
+  const packageJsonPath = `${projectPath}/package.json`;
+  const packageJson = (0, import_devkit.readJson)(tree, packageJsonPath);
+  for (const section of [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies"
+  ]) {
+    if (!packageJson[section]) continue;
+    for (const dep of Object.keys(packageJson[section])) {
+      if (dep.startsWith("@botonic/")) {
+        packageJson[section][dep] = exactVersion;
+      }
+    }
+  }
+  tree.write(packageJsonPath, JSON.stringify(packageJson, null, 2));
+}
+function getCurrentBotonicCoreVersion(tree, projectPath) {
+  try {
+    const packageJsonPath = `${projectPath}/package.json`;
+    if (!tree.exists(packageJsonPath)) {
+      return null;
+    }
+    const packageJson = (0, import_devkit.readJson)(tree, packageJsonPath);
+    const dependencies = {
+      ...packageJson.dependencies,
+      ...packageJson.devDependencies
+    };
+    const coreVersion = dependencies["@botonic/core"];
+    if (!coreVersion) {
+      return null;
+    }
+    return coreVersion.replace(/[\^~]/, "");
+  } catch (error) {
+    return null;
+  }
+}
+function getMigrationTargetVersion(tree, migrationName) {
+  try {
+    const migrationsJsonPath = "migrations.json";
+    if (!tree.exists(migrationsJsonPath)) {
+      throw new Error(
+        `Could not find migrations.json in workspace root. Make sure to run 'nx migrate @botonic/nx-plugin@latest' first.`
+      );
+    }
+    const migrationsJson = (0, import_devkit.readJson)(tree, migrationsJsonPath);
+    if (Array.isArray(migrationsJson.migrations)) {
+      const migration = migrationsJson.migrations.find(
+        (m) => m.name === migrationName
+      );
+      if (migration?.version) {
+        return migration.version;
+      }
+    }
+    if (!migrationsJson.migrations || migrationsJson.migrations.length === 0) {
+      throw new Error(
+        `Could not find migration version for '${migrationName}' in migrations.json`
+      );
+    }
+    return null;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error("Error finding migration target version:", errorMessage);
+    return null;
+  }
+}
+function findBotApps(tree) {
+  const projects = [];
+  try {
+    const projectsMap = (0, import_devkit.getProjects)(tree);
+    console.log(`Found ${projectsMap.size} projects in workspace configuration`);
+    for (const [projectName, projectConfig] of projectsMap.entries()) {
+      console.log(`Checking project: ${projectName} at ${projectConfig.root}`);
+      if (projectConfig.tags?.includes("botonic:bot-app")) {
+        console.log(`\u2705 ${projectName} is a Botonic bot app (tagged)`);
+        projects.push(projectConfig.root);
+      } else {
+        console.log(`\u274C ${projectName} is not a Botonic bot app (no tag)`);
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(
+      "Could not read workspace configuration, falling back to manual detection:",
+      errorMessage
+    );
+    const manualProjects = findBotAppsManually(tree);
+    console.log(
+      `Found ${manualProjects.length} projects via manual detection:`,
+      manualProjects
+    );
+    return manualProjects;
+  }
+  return projects;
+}
+function findBotAppsManually(tree) {
+  const projects = [];
+  if (tree.exists("apps")) {
+    tree.children("apps").forEach((appDir) => {
+      const projectJsonPath = `apps/${appDir}/project.json`;
+      if (tree.exists(projectJsonPath)) {
+        try {
+          const projectJsonContent = tree.read(projectJsonPath, "utf-8");
+          if (!projectJsonContent) return;
+          const projectJson = JSON.parse(projectJsonContent);
+          if (projectJson.tags?.includes("botonic:bot-app")) {
+            projects.push(`apps/${appDir}`);
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          console.warn(
+            `Could not parse project.json for ${appDir}:`,
+            errorMessage
+          );
+        }
+      }
+    });
+  }
+  return projects;
+}
+function createBotonicMigrationConfig(config) {
+  return {
+    skipDependencyUpdates: false,
+    successTitle: "Migration completed!",
+    additionalSteps: [],
+    ...config
+  };
+}
+function createFileProcessor(fileProcessors) {
+  return async (tree, projectPath, targetBotonicVersion) => {
+    let filesChanged = 0;
+    let transformed = false;
+    for (const processor of fileProcessors) {
+      const filePath = processor.filePath(projectPath);
+      if (tree.exists(filePath) && processor.shouldProcess(tree, filePath)) {
+        const content = tree.read(filePath, "utf-8");
+        if (!content) continue;
+        const result = processor.processFile(
+          tree,
+          filePath,
+          content,
+          targetBotonicVersion
+        );
+        if (result.transformed) {
+          if (result.newContent) {
+            tree.write(filePath, result.newContent);
+          }
+          if (result.logMessage) {
+            import_devkit.logger.info(`  \u2705 ${result.logMessage}`);
+          }
+          filesChanged++;
+          transformed = true;
+        }
+      }
+    }
+    return { transformed, filesChanged };
+  };
+}
+async function runBotonicMigration(config) {
+  const {
+    tree,
+    options,
+    migrationKey,
+    migrationName,
+    processProject,
+    getSuccessMessage,
+    skipDependencyUpdates = false,
+    successTitle = "Migration completed!",
+    additionalSteps = []
+  } = config;
+  const tasks = [];
+  const botProjects = await selectBotProjectsForMigration(
+    tree,
+    options,
+    migrationName,
+    migrationKey
+  );
+  if (botProjects.length === 0) {
+    return;
+  }
+  const migrationVersion = getMigrationTargetVersion(tree, migrationKey);
+  if (!migrationVersion) {
+    import_devkit.logger.error(
+      `\u274C Could not find migration version for '${migrationKey}' in migrations.json`
+    );
+    import_devkit.logger.error("   Please ensure the migration is properly configured.");
+    throw new Error(`Migration version not found for ${migrationKey}`);
+  }
+  const targetBotonicVersion = migrationVersion.replace(/^[\^~]/, "");
+  import_devkit.logger.info(`\u{1F3AF} Target Botonic version: ${targetBotonicVersion}`);
+  let transformedProjects = 0;
+  let transformedFiles = 0;
+  for (const projectPath of botProjects) {
+    import_devkit.logger.info(`\u{1F527} Processing project: ${projectPath.replace("apps/", "")}`);
+    const result = await processProject(tree, projectPath, targetBotonicVersion);
+    let projectTransformed = result.transformed;
+    transformedFiles += result.filesChanged;
+    if (!skipDependencyUpdates) {
+      const packageJsonPath = `${projectPath}/package.json`;
+      if (tree.exists(packageJsonPath)) {
+        import_devkit.logger.info(
+          `  \u2705 Updating Botonic dependencies to version ${targetBotonicVersion}`
+        );
+        updateBotonicDependencies(tree, targetBotonicVersion, projectPath);
+        transformedFiles++;
+        projectTransformed = true;
+      }
+    }
+    if (projectTransformed) {
+      transformedProjects++;
+    } else {
+      import_devkit.logger.info(
+        `  \u2139\uFE0F  No changes needed for ${projectPath.replace("apps/", "")} (already up to date)`
+      );
+    }
+  }
+  await (0, import_devkit.formatFiles)(tree);
+  import_devkit.logger.info(`\u2728 Migration completed successfully!`);
+  import_devkit.logger.info(
+    `   \u{1F4CA} Projects processed: ${transformedProjects}/${botProjects.length}`
+  );
+  import_devkit.logger.info(`   \u{1F4C4} Files transformed: ${transformedFiles}`);
+  if (transformedFiles > 0) {
+    import_devkit.logger.info(``);
+    import_devkit.logger.info(`\u{1F389} ${successTitle}`);
+    import_devkit.logger.info(``);
+    import_devkit.logger.info(`\u{1F4DD} What changed:`);
+    const successMessages = getSuccessMessage(targetBotonicVersion);
+    successMessages.forEach((message) => import_devkit.logger.info(`   ${message}`));
+    if (additionalSteps.length > 0) {
+      import_devkit.logger.info(``);
+      import_devkit.logger.info(`\u{1F4CB} Additional steps:`);
+      additionalSteps.forEach((step) => import_devkit.logger.info(`   ${step}`));
+    }
+    import_devkit.logger.info(``);
+    import_devkit.logger.info(`\u{1F527} Next steps:`);
+    import_devkit.logger.info(`   \u2022 Test your bot to ensure everything works correctly`);
+    import_devkit.logger.info(`   \u2022 Check git diff to review all changes made`);
+  } else {
+    import_devkit.logger.info(``);
+    import_devkit.logger.info(`\u2728 All specified projects are already up to date!`);
+  }
+  return (0, import_devkit.runTasksInSerial)(...tasks);
+}
+async function selectBotProjectsForMigration(tree, options, migrationName, migrationKey) {
+  const { projects: targetProjects, skipPrompt = false } = options;
+  const targetVersion = migrationKey ? getMigrationTargetVersion(tree, migrationKey) : null;
+  import_devkit.logger.info(`\u{1F504} Starting ${migrationName} migration...`);
+  if (targetVersion) {
+    import_devkit.logger.info(`\u{1F3AF} Target version: v${targetVersion}`);
+  }
+  const allBotProjects = findBotApps(tree);
+  if (allBotProjects.length === 0) {
+    import_devkit.logger.info("\u2139\uFE0F  No Botonic bot apps found. Skipping migration.");
+    return [];
+  }
+  let botProjects;
+  if (targetProjects && targetProjects.length > 0) {
+    const invalidProjects = targetProjects.filter((project) => {
+      const projectPath = project.startsWith("apps/") ? project : `apps/${project}`;
+      return !allBotProjects.includes(projectPath);
+    });
+    if (invalidProjects.length > 0) {
+      import_devkit.logger.error(
+        `\u274C The following projects are not valid Botonic bot apps: ${invalidProjects.join(", ")}`
+      );
+      import_devkit.logger.info(
+        `\u{1F4A1} Available bot apps: ${allBotProjects.map((p) => p.replace("apps/", "")).join(", ")}`
+      );
+      return [];
+    }
+    botProjects = targetProjects.map(
+      (project) => project.startsWith("apps/") ? project : `apps/${project}`
+    );
+    import_devkit.logger.info(
+      `\u{1F3AF} Targeting specific bot apps: ${botProjects.map((p) => p.replace("apps/", "")).join(", ")}`
+    );
+    for (const projectPath of botProjects) {
+      const currentVersion = getCurrentBotonicCoreVersion(tree, projectPath);
+      const projectName = projectPath.replace("apps/", "");
+      if (currentVersion && targetVersion) {
+        import_devkit.logger.info(
+          `   \u{1F4E6} ${projectName}: v${currentVersion} \u2192 v${targetVersion}`
+        );
+      } else if (currentVersion) {
+        import_devkit.logger.info(`   \u{1F4E6} ${projectName}: v${currentVersion}`);
+      } else {
+        import_devkit.logger.info(`   \u{1F4E6} ${projectName}: version unknown`);
+      }
+    }
+  } else if (!skipPrompt && allBotProjects.length > 1) {
+    import_devkit.logger.info(`\u{1F4E6} Found ${allBotProjects.length} Botonic bot app(s)`);
+    import_devkit.logger.info("\u{1F3AF} Select which apps to migrate:\n");
+    try {
+      const projectChoices = allBotProjects.map(
+        (projectPath) => {
+          const projectName = projectPath.replace("apps/", "");
+          const currentVersion = getCurrentBotonicCoreVersion(tree, projectPath);
+          let displayName = projectName;
+          if (currentVersion) {
+            displayName = `${projectName} (v${currentVersion})`;
+          }
+          let hint = "";
+          if (currentVersion && targetVersion) {
+            hint = `v${currentVersion} \u2192 v${targetVersion}`;
+          } else if (currentVersion) {
+            hint = `Current: v${currentVersion}`;
+          } else {
+            hint = "version unknown";
+          }
+          return {
+            name: projectPath,
+            message: displayName,
+            hint
+          };
+        }
+      );
+      const response = await (0, import_enquirer.prompt)({
+        type: "multiselect",
+        name: "selectedProjects",
+        message: targetVersion ? `Which bot apps would you like to apply ${migrationName} to? (Target: v${targetVersion})` : `Which bot apps would you like to apply ${migrationName} to?`,
+        choices: projectChoices,
+        result(names) {
+          return names;
+        }
+      });
+      botProjects = response.selectedProjects;
+      if (botProjects.length === 0) {
+        import_devkit.logger.info("\u2139\uFE0F  No bot apps selected. Skipping migration.");
+        return [];
+      }
+      import_devkit.logger.info(
+        `
+\u{1F3AF} Selected bot apps: ${botProjects.map((p) => p.replace("apps/", "")).join(", ")}`
+      );
+      for (const projectPath of botProjects) {
+        const currentVersion = getCurrentBotonicCoreVersion(tree, projectPath);
+        const projectName = projectPath.replace("apps/", "");
+        if (currentVersion && targetVersion) {
+          import_devkit.logger.info(
+            `   \u{1F4E6} ${projectName}: v${currentVersion} \u2192 v${targetVersion}`
+          );
+        } else if (currentVersion) {
+          import_devkit.logger.info(`   \u{1F4E6} ${projectName}: v${currentVersion}`);
+        } else {
+          import_devkit.logger.info(`   \u{1F4E6} ${projectName}: version unknown`);
+        }
+      }
+    } catch (error) {
+      import_devkit.logger.warn(
+        "\u26A0\uFE0F  Interactive selection not available. Processing all bot apps."
+      );
+      botProjects = allBotProjects;
+    }
+  } else {
+    botProjects = allBotProjects;
+    import_devkit.logger.info(
+      `\u{1F4E6} Found ${botProjects.length} Botonic bot app(s): ${botProjects.map((p) => p.replace("apps/", "")).join(", ")}`
+    );
+    for (const projectPath of botProjects) {
+      const currentVersion = getCurrentBotonicCoreVersion(tree, projectPath);
+      const projectName = projectPath.replace("apps/", "");
+      if (currentVersion && targetVersion) {
+        import_devkit.logger.info(
+          `   \u{1F4E6} ${projectName}: v${currentVersion} \u2192 v${targetVersion}`
+        );
+      } else if (currentVersion) {
+        import_devkit.logger.info(`   \u{1F4E6} ${projectName}: v${currentVersion}`);
+      } else {
+        import_devkit.logger.info(`   \u{1F4E6} ${projectName}: version unknown`);
+      }
+    }
+  }
+  return botProjects;
+}
+function getPluginVersion(moduleDir) {
+  try {
+    const pkgJsonPath = path.resolve(
+      moduleDir,
+      "..",
+      "..",
+      "..",
+      "package.json"
+    );
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+    return pkgJson.version || "latest";
+  } catch {
+    return "latest";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createBotonicMigrationConfig,
+  createFileProcessor,
+  findBotApps,
+  getCurrentBotonicCoreVersion,
+  getMigrationTargetVersion,
+  getPluginVersion,
+  runBotonicMigration,
+  selectBotProjectsForMigration,
+  updateBotonicDependencies
+});

package/src/plugin.d.ts

@@ -0,0 +1,15 @@
+import { CreateNodesV2 } from '@nx/devkit';
+export interface BotonicPluginOptions {
+    buildTargetName?: string;
+    serveTargetName?: string;
+    testTargetName?: string;
+    lintTargetName?: string;
+}
+export declare const createNodesV2: CreateNodesV2<BotonicPluginOptions>;
+/**
+ * Plugin configuration for nx.json
+ */
+export declare const BotonicPlugin: {
+    name: string;
+    createNodesV2: CreateNodesV2<BotonicPluginOptions>;
+};

package/src/plugin.js

@@ -0,0 +1,246 @@
+"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 plugin_exports = {};
+__export(plugin_exports, {
+  BotonicPlugin: () => BotonicPlugin,
+  createNodesV2: () => createNodesV2
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_devkit = require("@nx/devkit");
+var import_fs = require("fs");
+var import_path = require("path");
+const DEFAULT_OPTIONS = {
+  buildTargetName: "build",
+  serveTargetName: "serve",
+  testTargetName: "test",
+  lintTargetName: "lint"
+};
+const botonicCreateNodesFunction = async (configFiles, options, context) => {
+  const normalizedOptions = { ...DEFAULT_OPTIONS, ...options };
+  const results = [];
+  for (const projectJsonPath of configFiles) {
+    const projectRoot = (0, import_path.dirname)(projectJsonPath);
+    try {
+      const projectJson = await readProjectJson(projectJsonPath, context);
+      if (!isBotonicProject(projectJson)) {
+        continue;
+      }
+      import_devkit.logger.debug(
+        `[Botonic Plugin] Detected Botonic project at: ${projectRoot}`
+      );
+      const targets = await createBotonicTargets(
+        projectRoot,
+        normalizedOptions,
+        context
+      );
+      const result = {
+        projects: {
+          [projectRoot]: {
+            targets
+          }
+        }
+      };
+      results.push([projectJsonPath, result]);
+    } catch (error) {
+      import_devkit.logger.warn(
+        `[Botonic Plugin] Error processing ${projectJsonPath}: ${error.message}`
+      );
+    }
+  }
+  return results;
+};
+const createNodesV2 = [
+  "**/project.json",
+  botonicCreateNodesFunction
+];
+async function readProjectJson(projectJsonPath, context) {
+  try {
+    const fullPath = (0, import_path.join)(context.workspaceRoot, projectJsonPath);
+    const projectJsonContent = (0, import_fs.readFileSync)(fullPath, "utf-8");
+    return JSON.parse(projectJsonContent);
+  } catch (error) {
+    import_devkit.logger.debug(
+      `[Botonic Plugin] Could not read ${projectJsonPath}: ${error.message}`
+    );
+    return null;
+  }
+}
+function isBotonicProject(projectConfig) {
+  if (!projectConfig) return false;
+  const hasBotonicTag = projectConfig.tags?.includes("botonic:bot-app") ?? false;
+  const isApplication = projectConfig.projectType === "application";
+  return hasBotonicTag && isApplication;
+}
+const configurations = {
+  local: {
+    configuration: "local"
+  },
+  dev2: {
+    configuration: "dev2",
+    env: {
+      VITE_HUBTYPE_CLIENT_ID: "WlvymZ703Y5zGnmaCZ9Da5vf0lNX08jFvgC4pRMT",
+      VITE_HUBTYPE_API_URL: "https://api.dev2.dev.dev.hubtype.com",
+      VITE_PUSHER_API_PREFIX: "dev-dev-dev2"
+    }
+  },
+  dev: {
+    configuration: "dev",
+    env: {
+      VITE_HUBTYPE_CLIENT_ID: "AcIVeUMYaqH6O17LiCzbR3phZcRmfxYQNYFMr3BI",
+      VITE_HUBTYPE_API_URL: "https://api.dev.dev.dev.hubtype.com",
+      VITE_PUSHER_API_PREFIX: "dev-dev-dev"
+    }
+  },
+  qa: {
+    configuration: "qa",
+    env: {
+      VITE_HUBTYPE_CLIENT_ID: "kf7Dr7wLBMxZ9bKYIyZE4fzBpDlWGp4yR9CnXa5v",
+      VITE_HUBTYPE_API_URL: "https://api.int.qa.hubtype.com",
+      VITE_PUSHER_API_PREFIX: "qa-test-int"
+    }
+  },
+  prod: {
+    configuration: "prod",
+    env: {
+      VITE_HUBTYPE_CLIENT_ID: "jOIYDdvcfwqwSs7ZJ1CpmTKcE7UDapZDOSobFmEp",
+      VITE_HUBTYPE_API_URL: "https://api.hubtype.com",
+      VITE_PUSHER_API_PREFIX: "prod-ent0-ent0"
+    }
+  }
+};
+async function createBotonicTargets(projectRoot, options, context) {
+  const targets = {};
+  import_devkit.logger.debug(
+    `[Botonic Plugin] Creating all Botonic targets for ${projectRoot}`
+  );
+  targets["run-lambda"] = {
+    executor: "@botonic/nx-plugin:run-lambda",
+    options: {
+      lambdaPath: "src/server/lambda"
+    },
+    continuous: true,
+    dependsOn: ["build-node-app-watch"]
+  };
+  targets[options.serveTargetName] = {
+    executor: "@botonic/nx-plugin:serve-bot",
+    options: {},
+    configurations,
+    continuous: true
+  };
+  targets["serve:webchat"] = {
+    executor: "@botonic/nx-plugin:serve-bot",
+    options: {
+      skipWebviews: true
+    },
+    configurations,
+    continuous: true
+  };
+  targets["serve:webview"] = {
+    executor: "@botonic/nx-plugin:serve-bot",
+    options: {},
+    configurations,
+    continuous: true
+  };
+  targets["serve-dev"] = {
+    executor: "@botonic/nx-plugin:serve-bot",
+    options: {},
+    configurations,
+    continuous: true
+  };
+  targets["serve-dev-tunnel"] = {
+    executor: "@botonic/nx-plugin:serve-bot",
+    options: {},
+    configurations,
+    continuous: true
+  };
+  targets["build-node-app"] = {
+    executor: "nx:run-commands",
+    options: {
+      command: `VITE_CJS_IGNORE_WARNING=true BUILD_TARGET=node vite build --config ${projectRoot}/vite.config.ts`,
+      forwardAllArgs: false
+    },
+    configurations
+  };
+  targets["build-node-app-watch"] = {
+    executor: "nx:run-commands",
+    options: {
+      command: `VITE_CJS_IGNORE_WARNING=true BUILD_TARGET=node vite build --config ${projectRoot}/vite.config.ts --watch`,
+      forwardAllArgs: false
+    },
+    continuous: true,
+    configurations
+  };
+  targets["build-webchat-app"] = {
+    executor: "nx:run-commands",
+    options: {
+      command: `TARGET_APP=webchat vite build --config ${projectRoot}/vite.config.ts`,
+      forwardAllArgs: false
+    },
+    configurations
+  };
+  targets["build-webviews-app"] = {
+    executor: "nx:run-commands",
+    options: {
+      command: `TARGET_APP=webviews vite build --config ${projectRoot}/vite.config.ts`,
+      forwardAllArgs: false
+    },
+    configurations
+  };
+  targets["login-to-hubtype"] = {
+    executor: "@botonic/nx-plugin:login-to-hubtype",
+    configurations
+  };
+  targets["logout-from-hubtype"] = {
+    executor: "@botonic/nx-plugin:logout-from-hubtype"
+  };
+  targets["deploy-to-hubtype"] = {
+    executor: "@botonic/nx-plugin:deploy-to-hubtype",
+    configurations
+  };
+  targets["deploy-local-runtime"] = {
+    executor: "@botonic/nx-plugin:deploy-local-runtime",
+    configurations
+  };
+  targets["integrate-provider"] = {
+    executor: "@botonic/nx-plugin:integrate-provider",
+    configurations
+  };
+  targets["delete-bot"] = {
+    executor: "@botonic/nx-plugin:delete-bot",
+    configurations
+  };
+  targets["deploy-netlify-snapshot"] = {
+    executor: "@botonic/nx-plugin:deploy-netlify-snapshot",
+    options: {}
+  };
+  targets["e2e-webchat"] = {
+    executor: "@botonic/nx-plugin:e2e-webchat",
+    options: {}
+  };
+  return targets;
+}
+const BotonicPlugin = {
+  name: "@botonic/nx-plugin",
+  createNodesV2
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotonicPlugin,
+  createNodesV2
+});