@botonic/nx-plugin 2.23.0

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

@@ -0,0 +1,330 @@
+"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: () => serveBotExecutor
+});
+module.exports = __toCommonJS(executor_exports);
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_path = require("path");
+var readline = __toESM(require("readline"));
+var import_cloudflared_tunnel = require("../../lib/cloudflared-tunnel");
+var import_executor_helpers = require("../../lib/util/executor-helpers");
+var import_sam_container_cleanup = require("../../lib/util/sam-container-cleanup");
+const colors = {
+  bot: "\x1B[36m",
+  // Cyan
+  lambda: "\x1B[33m",
+  // Yellow
+  webchat: "\x1B[32m",
+  // Green
+  webviews: "\x1B[35m",
+  // Magenta
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m"
+};
+function getAppIdFromEnvFile(projectRoot) {
+  const envFilePath = (0, import_path.join)(projectRoot, ".env.local");
+  if (!(0, import_fs.existsSync)(envFilePath)) {
+    return null;
+  }
+  try {
+    const envContent = (0, import_fs.readFileSync)(envFilePath, "utf8");
+    const lines = envContent.split("\n");
+    const appIdKey = "VITE_HUBTYPE_APP_ID";
+    for (const line of lines) {
+      if (line.startsWith(`${appIdKey}=`)) {
+        return line.split("=")[1]?.trim();
+      }
+    }
+    return null;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.warn(`\u26A0\uFE0F  Could not read .env.local file: ${errorMessage}`);
+    return null;
+  }
+}
+function prefixOutput(stream, prefix, color) {
+  if (!stream) return;
+  const rl = readline.createInterface({ input: stream });
+  rl.on("line", (line) => {
+    const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+    console.log(
+      `${colors.dim}${timestamp}${colors.reset} ${color}[${prefix}]${colors.reset} ${line}`
+    );
+  });
+}
+function spawnProcess(command, name, color, cwd) {
+  const child = (0, import_child_process.spawn)("sh", ["-c", command], {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, FORCE_COLOR: "1" }
+  });
+  prefixOutput(child.stdout, name, color);
+  prefixOutput(child.stderr, name, color);
+  return { name, color, process: child };
+}
+async function serveBotExecutor(options, context) {
+  if (!context.projectName) {
+    throw new Error("Project name is required");
+  }
+  const projectRoot = context.projectsConfigurations?.projects?.[context.projectName]?.root;
+  if (!projectRoot) {
+    throw new Error(`Could not find project root for ${context.projectName}`);
+  }
+  const configuration = options.configuration || "prod";
+  const fullProjectRoot = (0, import_path.join)(context.root, projectRoot);
+  const configPath = (0, import_path.join)(context.root, projectRoot, "vite.config.ts");
+  const appId = getAppIdFromEnvFile(fullProjectRoot);
+  if (!appId) {
+    console.warn(
+      `\u26A0\uFE0F  VITE_HUBTYPE_APP_ID not found in .env.local \u2014 will be set automatically after deploy`
+    );
+  }
+  console.log(`${colors.dim}Clearing Vite cache...${colors.reset}`);
+  const viteCacheDirs = [
+    (0, import_path.join)(context.root, "node_modules", ".vite"),
+    (0, import_path.join)(fullProjectRoot, "node_modules", ".vite"),
+    (0, import_path.join)(fullProjectRoot, ".vite")
+  ];
+  for (const dir of viteCacheDirs) {
+    try {
+      if ((0, import_fs.existsSync)(dir)) {
+        (0, import_child_process.execSync)(`rm -rf "${dir}"`, { stdio: "pipe" });
+      }
+    } catch {
+    }
+  }
+  console.log(`${colors.dim}Vite cache cleared.${colors.reset}`);
+  const cleanupResult = (0, import_sam_container_cleanup.cleanupPreviousSamContainersByLabel)(fullProjectRoot);
+  if (cleanupResult === "removed") {
+    console.log(
+      `${colors.dim}[lambda] Removed previous run's container (reused slot).${colors.reset}`
+    );
+  } else if (cleanupResult === "none") {
+    console.log(
+      `${colors.dim}[lambda] No previous Lambda container to clean up.${colors.reset}`
+    );
+  }
+  const useTunnel = true;
+  const tunnelPort = options.tunnelPort ?? 3001;
+  let effectiveLambdaEndpoint = options.lambdaEndpoint;
+  let startLambda = !options.skipLambda && !effectiveLambdaEndpoint;
+  let tunnelBotId;
+  let tunnelDeployResult;
+  if (useTunnel) {
+    await (0, import_executor_helpers.ensureHubtypeLoginBeforeTunnel)(context, fullProjectRoot, {
+      env: options.env,
+      configuration
+    });
+    await (0, import_executor_helpers.ensureLocalRuntimeBotBeforeTunnel)(context, fullProjectRoot, {
+      env: options.env,
+      configuration
+    });
+    console.log(
+      `${colors.dim}Starting tunnel flow (Lambda + cloudflared + deploy_local_runtime)...${colors.reset}
+`
+    );
+  }
+  const processes = [];
+  try {
+    if (useTunnel) {
+      const lambdaPath = (0, import_path.join)(fullProjectRoot, "src/server/lambda");
+      const lambdaCommand = "sam local start-lambda --warm-containers EAGER --skip-pull-image";
+      processes.push(
+        spawnProcess(lambdaCommand, "lambda", colors.lambda, lambdaPath)
+      );
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+      console.log(
+        `${colors.dim}Starting Cloudflare tunnel (cloudflared)...${colors.reset}`
+      );
+      const { url: tunnelUrl, process: cloudflaredProcess } = await (0, import_cloudflared_tunnel.startCloudflaredTunnel)(tunnelPort);
+      processes.push({
+        name: "tunnel",
+        color: colors.lambda,
+        process: cloudflaredProcess
+      });
+      console.log(`${colors.dim}Tunnel URL: ${tunnelUrl}${colors.reset}
+`);
+      console.log(
+        `${colors.dim}Registering tunnel with backend (deploy_local_runtime)...${colors.reset}`
+      );
+      const deployResult = await (0, import_executor_helpers.performDeployLocalRuntimeWithEndpoint)(
+        context,
+        fullProjectRoot,
+        tunnelUrl,
+        { env: options.env, configuration }
+      );
+      tunnelBotId = deployResult.botId;
+      tunnelDeployResult = {
+        targetEnvironment: deployResult.targetEnvironment,
+        environmentVariables: deployResult.environmentVariables
+      };
+      effectiveLambdaEndpoint = tunnelUrl;
+      startLambda = false;
+    }
+  } catch (tunnelError) {
+    const msg = tunnelError instanceof Error ? tunnelError.message : String(tunnelError);
+    console.error(`\u274C Tunnel flow failed: ${msg}`);
+    return { success: false };
+  }
+  let effectiveAppId = appId;
+  if (useTunnel) {
+    const latestAppId = (0, import_executor_helpers.getAppIdFromEnvFileForConfig)(
+      fullProjectRoot,
+      configuration
+    );
+    if (latestAppId) effectiveAppId = latestAppId;
+  }
+  if (configuration !== "local" && effectiveAppId) {
+    await (0, import_executor_helpers.writeAppIdToEnvFile)(fullProjectRoot, effectiveAppId, configuration);
+    if (tunnelBotId) {
+      (0, import_executor_helpers.writeEnvVarToEnvFile)(
+        fullProjectRoot,
+        "VITE_HUBTYPE_BOT_ID",
+        tunnelBotId,
+        configuration
+      );
+    }
+  }
+  const useExternalLambda = Boolean(effectiveLambdaEndpoint);
+  if (!useTunnel) {
+    startLambda = !options.skipLambda && !useExternalLambda;
+  }
+  console.log(`
+${colors.bold}\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+\u2551              \u{1F680} Botonic Dev Server                         \u2551
+\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D${colors.reset}
+
+${colors.dim}Project:${colors.reset}       ${context.projectName}
+${colors.dim}Configuration:${colors.reset} ${configuration}
+${colors.dim}App ID:${colors.reset}        ${effectiveAppId}
+${useExternalLambda ? `${colors.dim}Lambda (external):${colors.reset} ${effectiveLambdaEndpoint}
+` : ""}
+${colors.bot}[bot]${colors.reset}      - Node/Lambda build watcher
+${startLambda ? `${colors.lambda}[lambda]${colors.reset}   - AWS SAM local lambda server` : useExternalLambda ? `${colors.lambda}[lambda]${colors.reset}   - Using external endpoint (no Docker)` : ""}
+${colors.webchat}[webchat]${colors.reset}  - Webchat Vite dev server
+${colors.webviews}[webviews]${colors.reset} - Webviews Vite dev server
+`);
+  if (useExternalLambda && !useTunnel) {
+    console.log(
+      `${colors.dim}\u{1F4A1} Ensure you have run deploy_local_runtime with this URL so the backend can invoke your Lambda.${colors.reset}
+`
+    );
+  }
+  for (const dir of viteCacheDirs) {
+    try {
+      if ((0, import_fs.existsSync)(dir)) {
+        (0, import_child_process.execSync)(`rm -rf "${dir}"`, { stdio: "pipe" });
+      }
+    } catch {
+    }
+  }
+  try {
+    const buildCommand = `VITE_CJS_IGNORE_WARNING=true BUILD_TARGET=node vite build --config ${configPath} --watch`;
+    processes.push(
+      spawnProcess(buildCommand, "bot", colors.bot, fullProjectRoot)
+    );
+    await new Promise((resolve) => setTimeout(resolve, 3e3));
+    if (startLambda) {
+      const lambdaPath = (0, import_path.join)(fullProjectRoot, "src/server/lambda");
+      const lambdaCommand = "sam local start-lambda --warm-containers EAGER --skip-pull-image";
+      processes.push(
+        spawnProcess(lambdaCommand, "lambda", colors.lambda, lambdaPath)
+      );
+      await new Promise((resolve) => setTimeout(resolve, 2e3));
+    }
+    const noOpenEnv = options.open === false ? "VITE_SERVE_OPEN=false " : "";
+    const viteEnvAppId = `VITE_HUBTYPE_APP_ID=${effectiveAppId}`;
+    const viteEnvBotId = tunnelBotId != null ? ` VITE_HUBTYPE_BOT_ID=${tunnelBotId}` : "";
+    const webchatCommand = `${noOpenEnv}${viteEnvAppId}${viteEnvBotId} TARGET_APP=webchat MODE=${configuration} vite --config ${configPath}`;
+    processes.push(
+      spawnProcess(webchatCommand, "webchat", colors.webchat, fullProjectRoot)
+    );
+    if (!options.skipWebviews) {
+      const webviewsCommand = `${noOpenEnv}${viteEnvAppId}${viteEnvBotId} TARGET_APP=webviews MODE=${configuration} vite --config ${configPath}`;
+      processes.push(
+        spawnProcess(
+          webviewsCommand,
+          "webviews",
+          colors.webviews,
+          fullProjectRoot
+        )
+      );
+    }
+    let cleanupCalled = false;
+    const cleanup = () => {
+      if (cleanupCalled) return;
+      cleanupCalled = true;
+      console.log(
+        `
+${colors.bold}\u{1F6D1} Shutting down all processes...${colors.reset}`
+      );
+      processes.forEach(({ name, color, process: proc }) => {
+        console.log(`${color}[${name}]${colors.reset} Stopping...`);
+        proc.kill("SIGTERM");
+      });
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+    process.on("exit", cleanup);
+    return new Promise((resolve) => {
+      let exitCount = 0;
+      const totalProcesses = processes.length;
+      processes.forEach(({ name, color, process: proc }) => {
+        proc.on("exit", (code) => {
+          console.log(
+            `${color}[${name}]${colors.reset} Process exited with code ${code}`
+          );
+          exitCount++;
+          if (code !== 0 && code !== null) {
+            cleanup();
+            resolve({ success: false });
+          }
+          if (exitCount === totalProcesses) {
+            resolve({ success: true });
+          }
+        });
+        proc.on("error", (error) => {
+          console.error(
+            `${color}[${name}]${colors.reset} Error: ${error.message}`
+          );
+          cleanup();
+          resolve({ success: false });
+        });
+      });
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u274C Error starting dev server:`, errorMessage);
+    return { success: false };
+  }
+}

package/src/executors/serve-bot/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/serve-bot/schema.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "ServeBot executor",
+  "description": "Serve Botonic app with all processes (build, lambda, webchat, webviews) running in parallel with labeled output",
+  "type": "object",
+  "properties": {
+    "configuration": {
+      "type": "string",
+      "description": "Configuration/environment to use",
+      "enum": ["local", "dev", "dev2", "qa", "prod"],
+      "default": "local"
+    },
+    "skipWebviews": {
+      "type": "boolean",
+      "description": "Skip starting the webviews server",
+      "default": false
+    },
+    "skipLambda": {
+      "type": "boolean",
+      "description": "Skip starting the lambda server (useful if running lambda externally)",
+      "default": false
+    },
+    "lambdaEndpoint": {
+      "type": "string",
+      "description": "Use an external Lambda endpoint (e.g. ngrok URL) instead of starting sam local start-lambda. When set, the Lambda server is not started (it is already running elsewhere). Also run deploy_local_runtime with this URL so the backend can invoke your Lambda."
+    },
+    "open": {
+      "type": "boolean",
+      "description": "Open browser for webchat dev server",
+      "default": true
+    },
+    "tunnelPort": {
+      "type": "number",
+      "description": "Local port the Lambda listens on (used for cloudflared --url). Default 3001.",
+      "default": 3001
+    }
+  },
+  "required": []
+}

package/src/generators/action/files/__name__.spec.ts.template

@@ -0,0 +1,15 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { <%= className %> } from './<%= fileName %>'
+
+describe('<%= className %>', () => {
+  it('should call sendMessage and return OK', async () => {
+    const sendMessage = vi.fn().mockResolvedValue(undefined)
+    const mockContext = { sendMessage } as any
+
+    const result = await <%= className %>(mockContext)
+
+    expect(sendMessage).toHaveBeenCalledOnce()
+    expect(result).toEqual({ status: 200, response: 'OK' })
+  })
+})

package/src/generators/action/files/__name__.ts.template

@@ -0,0 +1,15 @@
+import { BotContext, BotServerMessageFactory } from '@botonic/shared'
+
+export async function <%= className %>({ sendMessage }: BotContext) {
+  // TODO: Implement your action logic here
+  await sendMessage(
+    BotServerMessageFactory.createText({
+      text: 'Hello from <%= className %>!',
+    })
+  )
+
+  return {
+    status: 200,
+    response: 'OK',
+  }
+}

package/src/generators/action/generator.d.ts

@@ -0,0 +1,4 @@
+import { Tree } from '@nx/devkit';
+import type { ActionGeneratorSchema } from './schema';
+export default function (tree: Tree, options: ActionGeneratorSchema): Promise<void>;
+export { ActionGeneratorSchema };

package/src/generators/action/generator.js

@@ -0,0 +1,112 @@
+"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 generator_exports = {};
+__export(generator_exports, {
+  default: () => generator_default
+});
+module.exports = __toCommonJS(generator_exports);
+var import_devkit = require("@nx/devkit");
+var import_bot_app_utils = require("../shared/bot-app-utils");
+const MODULE_DIR = __dirname;
+function normalizeOptions(tree, options) {
+  const { projectRoot, sourceRoot } = (0, import_bot_app_utils.validateBotAppProject)(
+    tree,
+    options.project
+  );
+  const paths = (0, import_bot_app_utils.resolveStandardPaths)(sourceRoot);
+  const name = (0, import_devkit.names)(options.name);
+  const fileName = name.fileName;
+  const className = name.className;
+  return {
+    ...options,
+    projectName: options.project,
+    projectRoot,
+    fileName,
+    className,
+    actionsPath: paths.actionsPath,
+    routesPath: paths.routesPath,
+    resolvedRouteMatcher: options.routeMatcher ?? fileName
+  };
+}
+function addFilesToProject(tree, options) {
+  const name = (0, import_devkit.names)(options.name);
+  const templateOptions = {
+    ...options,
+    ...name,
+    name: name.fileName
+    // __name__ in filenames must be kebab-case
+  };
+  (0, import_devkit.generateFiles)(
+    tree,
+    (0, import_devkit.joinPathFragments)(MODULE_DIR, "files"),
+    options.actionsPath,
+    templateOptions
+  );
+  if (options.skipTests) {
+    const testFilePath = `${options.actionsPath}/${options.fileName}.spec.ts`;
+    if (tree.exists(testFilePath)) {
+      tree.delete(testFilePath);
+    }
+  }
+}
+function updateActionsIndex(tree, options) {
+  (0, import_bot_app_utils.addExportToIndex)(
+    tree,
+    `${options.actionsPath}/index.ts`,
+    `export * from './${options.fileName}'`
+  );
+}
+function updateRoutes(tree, options) {
+  if (options.skipRoute) {
+    return;
+  }
+  (0, import_bot_app_utils.addActionImportToRoutes)(tree, options.routesPath, options.className);
+  (0, import_bot_app_utils.insertRouteBeforeFlowBuilder)(tree, options.routesPath, [
+    `    {`,
+    `      text: '${options.resolvedRouteMatcher}',`,
+    `      action: async () => await ${options.className}(botContext),`,
+    `    },`
+  ]);
+}
+async function generator_default(tree, options) {
+  console.log(`Creating action: ${options.name}`);
+  const normalizedOptions = normalizeOptions(tree, options);
+  console.log(`Project: ${normalizedOptions.projectName}`);
+  console.log(`Location: ${normalizedOptions.actionsPath}`);
+  addFilesToProject(tree, normalizedOptions);
+  updateActionsIndex(tree, normalizedOptions);
+  updateRoutes(tree, normalizedOptions);
+  await (0, import_devkit.formatFiles)(tree);
+  console.log(`
+Successfully created action: ${normalizedOptions.className}`);
+  console.log(`Next steps:`);
+  console.log(
+    `  1. Implement the logic in: ${normalizedOptions.actionsPath}/${normalizedOptions.fileName}.ts`
+  );
+  if (!options.skipRoute) {
+    console.log(
+      `  2. Test by sending '${normalizedOptions.resolvedRouteMatcher}' in the webchat`
+    );
+  }
+  if (!options.skipTests) {
+    console.log(
+      `  3. Update the tests in: ${normalizedOptions.actionsPath}/${normalizedOptions.fileName}.spec.ts`
+    );
+  }
+}

package/src/generators/action/schema.d.ts

@@ -0,0 +1,7 @@
+export interface ActionGeneratorSchema {
+    name: string;
+    project: string;
+    skipTests?: boolean;
+    skipRoute?: boolean;
+    routeMatcher?: string;
+}

package/src/generators/action/schema.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_exports = {};
+module.exports = __toCommonJS(schema_exports);

package/src/generators/action/schema.json

@@ -0,0 +1,43 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "Action",
+  "title": "Create a bot action for Botonic",
+  "description": "Generate a server-side bot action with automatic registration in routes.",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "The name of the action.",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use for the action?",
+      "pattern": "^[a-zA-Z].*$"
+    },
+    "project": {
+      "type": "string",
+      "description": "The name of the botonic project to add the action to.",
+      "x-prompt": "Which botonic project should this action be added to?",
+      "$default": {
+        "$source": "projectName"
+      }
+    },
+    "skipTests": {
+      "type": "boolean",
+      "description": "Skip generating test files.",
+      "default": false
+    },
+    "skipRoute": {
+      "type": "boolean",
+      "description": "Skip registering a route for this action in routes.ts.",
+      "default": false
+    },
+    "routeMatcher": {
+      "type": "string",
+      "description": "The text matcher for the route (defaults to the kebab-case action name)."
+    }
+  },
+  "required": ["name", "project"]
+}

package/src/generators/bot-app/files/.eslintrc.json.template

@@ -0,0 +1,18 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*", "**/node_modules/**", "node_modules", "dist"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    }
+  ]
+}