@botonic/nx-plugin 2.23.0

package/src/lib/bot-config.js

@@ -0,0 +1,203 @@
+"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 bot_config_exports = {};
+__export(bot_config_exports, {
+  BotConfig: () => BotConfig
+});
+module.exports = __toCommonJS(bot_config_exports);
+var childProcess = __toESM(require("child_process"));
+var import_fs = require("fs");
+var import_path = require("path");
+var util = __toESM(require("util"));
+const CONSTANTS_PATH = "src/shared/constants";
+const TOOLS_PATH = "src/server/bot/tools";
+class BotConfig {
+  static async get(projectRoot) {
+    const [botConfig, buildInfo, packages] = await Promise.all([
+      this.loadBotConfig(projectRoot),
+      this.getBuildInfo(projectRoot),
+      this.getBotonicPackages(projectRoot)
+    ]);
+    const config = {
+      build_info: buildInfo,
+      packages,
+      tools: botConfig.tools,
+      payloads: botConfig.payloads,
+      webviews: botConfig.webviews
+    };
+    this.displayBotConfig(config);
+    return config;
+  }
+  static displayBotConfig(config) {
+    console.log("\n" + "=".repeat(60));
+    console.log("\u{1F4CB} BOT CONFIGURATION");
+    console.log("=".repeat(60));
+    console.log("\n\u{1F527} Build Info:");
+    console.log(`  Node: ${config.build_info.node_version}`);
+    console.log(`  NPM: ${config.build_info.npm_version}`);
+    console.log(`  Botonic CLI: ${config.build_info.botonic_cli_version}`);
+    console.log("\n\u{1F4E6} Packages:");
+    Object.entries(config.packages).forEach(([name, info]) => {
+      console.log(`  ${name}: ${info.version}`);
+    });
+    console.log("\n\u{1F528} Tools:");
+    if (config.tools.length === 0) {
+      console.log("  (none)");
+    } else {
+      config.tools.forEach((tool) => {
+        console.log(`  \u2022 ${tool.name}: ${tool.description}`);
+      });
+    }
+    console.log("\n\u{1F4E8} Payloads:");
+    if (config.payloads.length === 0) {
+      console.log("  (none)");
+    } else {
+      config.payloads.forEach((payload) => {
+        console.log(`  \u2022 ${payload}`);
+      });
+    }
+    console.log("\n\u{1F310} Webviews:");
+    if (config.webviews.length === 0) {
+      console.log("  (none)");
+    } else {
+      config.webviews.forEach((webview) => {
+        console.log(`  \u2022 ${webview.name}`);
+      });
+    }
+    console.log("\n" + "=".repeat(60) + "\n");
+  }
+  static async loadBotConfig(projectRoot) {
+    const [tools, payloads, webviews] = await Promise.all([
+      this.getTools(projectRoot),
+      this.getPayloads(projectRoot),
+      this.getWebviews(projectRoot)
+    ]);
+    return { tools, payloads, webviews };
+  }
+  static async getTools(projectRoot) {
+    const toolsPath = (0, import_path.join)(projectRoot, TOOLS_PATH);
+    try {
+      const toolsModule = await import(toolsPath);
+      if (toolsModule.customTools && Array.isArray(toolsModule.customTools)) {
+        return toolsModule.customTools.map(
+          (tool) => ({
+            name: tool.name,
+            description: tool.description
+          })
+        );
+      }
+    } catch {
+      console.warn(`Tools not found in ${toolsPath}`);
+    }
+    return [];
+  }
+  static async loadModuleConstant(modulePath, constantName, transformer) {
+    try {
+      const module2 = await import(modulePath);
+      if (module2[constantName] && typeof module2[constantName] === "object") {
+        const values = Object.values(module2[constantName]);
+        return transformer ? values.map(transformer) : values;
+      }
+    } catch {
+      console.warn(`${constantName} not found in ${modulePath}`);
+    }
+    return [];
+  }
+  static async getPayloads(projectRoot) {
+    const constantsPath = (0, import_path.join)(projectRoot, CONSTANTS_PATH);
+    return this.loadModuleConstant(constantsPath, "PAYLOADS");
+  }
+  static async getWebviews(projectRoot) {
+    const constantsPath = (0, import_path.join)(projectRoot, CONSTANTS_PATH);
+    return this.loadModuleConstant(
+      constantsPath,
+      "WEBVIEWS",
+      (path) => ({ name: path })
+    );
+  }
+  static async getBuildInfo(projectRoot) {
+    const [nodeVersion, npmVersion] = await Promise.all([
+      this.getOutputByCommand("node -v"),
+      this.getOutputByCommand("pnpm -v")
+    ]);
+    let botonicCliVersion = "";
+    try {
+      const packageJsonPath = (0, import_path.join)(projectRoot, "package.json");
+      const packageJsonContent = (0, import_fs.readFileSync)(packageJsonPath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      botonicCliVersion = dependencies["@botonic/core"] || "";
+      botonicCliVersion = botonicCliVersion.replace(/[\^~]/, "");
+    } catch {
+      console.warn("Could not determine Botonic CLI version");
+    }
+    return {
+      node_version: nodeVersion,
+      npm_version: npmVersion,
+      botonic_cli_version: botonicCliVersion
+    };
+  }
+  static async getBotonicPackages(projectRoot) {
+    const packages = {};
+    try {
+      const packageJsonPath = (0, import_path.join)(projectRoot, "package.json");
+      const packageJsonContent = (0, import_fs.readFileSync)(packageJsonPath, "utf8");
+      const packageJson = JSON.parse(packageJsonContent);
+      const dependencies = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      const botonicPackages = Object.keys(dependencies).filter(
+        (dep) => dep.startsWith("@botonic/")
+      );
+      let coreVersion = dependencies["@botonic/core"] || "";
+      if (coreVersion) {
+        coreVersion = coreVersion.replace(/[\^~]/, "");
+      }
+      for (const packageName of botonicPackages) {
+        packages[packageName] = { version: coreVersion };
+      }
+    } catch {
+      console.error("Error getting Botonic packages:");
+    }
+    return packages;
+  }
+  static async getOutputByCommand(command) {
+    const exec = util.promisify(childProcess.exec);
+    const { stdout } = await exec(command);
+    return stdout.trim();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotConfig
+});

package/src/lib/cloudflared-tunnel.d.ts

@@ -0,0 +1,29 @@
+import { ChildProcess } from 'child_process';
+/**
+ * Default timeout (ms) to wait for cloudflared to output the quick tunnel URL.
+ * Cloudflared prints the URL to stdout when the tunnel is ready.
+ */
+export declare const DEFAULT_TUNNEL_URL_TIMEOUT_MS = 15000;
+/**
+ * Regex to extract the quick tunnel HTTPS URL from cloudflared output.
+ * Quick tunnels use trycloudflare.com (e.g. https://random-subdomain.trycloudflare.com).
+ * Documented: https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/do-more-with-tunnels/trycloudflare/
+ */
+export declare const TUNNEL_URL_REGEX: RegExp;
+export interface StartTunnelResult {
+    url: string;
+    process: ChildProcess;
+}
+/**
+ * Spawns cloudflared in quick-tunnel mode and returns a promise that resolves
+ * with the public HTTPS URL when it appears in stdout/stderr, or rejects on
+ * timeout or parse failure.
+ *
+ * Requires cloudflared on PATH (e.g. brew install cloudflare/cloudflare/cloudflared).
+ * No Cloudflare account or login required for quick tunnels.
+ *
+ * @param localPort - Port where the local service is listening (e.g. Lambda on 3001)
+ * @param timeoutMs - Max time to wait for the URL (default DEFAULT_TUNNEL_URL_TIMEOUT_MS)
+ * @returns Promise resolving with { url, process }. Caller must kill process on shutdown.
+ */
+export declare function startCloudflaredTunnel(localPort: number, timeoutMs?: number): Promise<StartTunnelResult>;

package/src/lib/cloudflared-tunnel.js

@@ -0,0 +1,95 @@
+"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 cloudflared_tunnel_exports = {};
+__export(cloudflared_tunnel_exports, {
+  DEFAULT_TUNNEL_URL_TIMEOUT_MS: () => DEFAULT_TUNNEL_URL_TIMEOUT_MS,
+  TUNNEL_URL_REGEX: () => TUNNEL_URL_REGEX,
+  startCloudflaredTunnel: () => startCloudflaredTunnel
+});
+module.exports = __toCommonJS(cloudflared_tunnel_exports);
+var import_child_process = require("child_process");
+const DEFAULT_TUNNEL_URL_TIMEOUT_MS = 15e3;
+const TUNNEL_URL_REGEX = /https:\/\/[a-zA-Z0-9-]+\.trycloudflare\.com/;
+function startCloudflaredTunnel(localPort, timeoutMs = DEFAULT_TUNNEL_URL_TIMEOUT_MS) {
+  return new Promise((resolve, reject) => {
+    const child = (0, import_child_process.spawn)(
+      "cloudflared",
+      ["tunnel", "--url", `http://localhost:${localPort}`],
+      {
+        stdio: ["ignore", "pipe", "pipe"]
+      }
+    );
+    let resolved = false;
+    const timeoutId = setTimeout(() => {
+      if (resolved) return;
+      resolved = true;
+      child.kill("SIGTERM");
+      reject(
+        new Error(
+          `cloudflared did not output a tunnel URL within ${timeoutMs}ms. Ensure cloudflared is installed (e.g. brew install cloudflare/cloudflare/cloudflared).`
+        )
+      );
+    }, timeoutMs);
+    const checkLine = (line) => {
+      if (resolved) return;
+      const match = line.match(TUNNEL_URL_REGEX);
+      if (match) {
+        resolved = true;
+        clearTimeout(timeoutId);
+        resolve({ url: match[0], process: child });
+      }
+    };
+    const onError = (err) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeoutId);
+      child.kill("SIGTERM");
+      reject(
+        new Error(
+          `cloudflared failed: ${err.message}. Ensure cloudflared is installed (e.g. brew install cloudflare/cloudflare/cloudflared).`
+        )
+      );
+    };
+    child.on("error", onError);
+    child.stdout?.on("data", (chunk) => {
+      const lines = chunk.toString().split(/\r?\n/);
+      lines.forEach(checkLine);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const lines = chunk.toString().split(/\r?\n/);
+      lines.forEach(checkLine);
+    });
+    child.on("exit", (code, signal) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeoutId);
+      reject(
+        new Error(
+          `cloudflared exited before providing a URL (code=${code}, signal=${signal})`
+        )
+      );
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_TUNNEL_URL_TIMEOUT_MS,
+  TUNNEL_URL_REGEX,
+  startCloudflaredTunnel
+});

package/src/lib/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const BOTONIC_NPM_NAMESPACE = "@botonic";
+export declare const BOTONIC_HOME_DIRNAME = ".botonic";
+export declare const GLOBAL_CREDS_FILENAME = "credentials.json";
+export declare const BOTONIC_PROJECT_PATH: string;
+export declare const BOT_CREDENTIALS_FILENAME = ".botonic.json";
+export declare const LOCAL_RUNTIME_BOT_CREDENTIALS_FILENAME = ".local-runtime-botonic.json";
+export declare const ANALYTICS_WRITE_KEY = "YD0jpJHNGW12uhLNbgB4wbdTRQ4Cy1Zu";
+export declare const CLOUD_PROVIDERS: Readonly<{
+    AWS: "aws";
+    HUBTYPE: "hubtype";
+}>;
+export declare const AWS_CLOUD_CONFIG_FILENAME = "aws.config.js";
+export declare const PATH_TO_AWS_CONFIG: string;

package/src/lib/constants.js

@@ -0,0 +1,60 @@
+"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 constants_exports = {};
+__export(constants_exports, {
+  ANALYTICS_WRITE_KEY: () => ANALYTICS_WRITE_KEY,
+  AWS_CLOUD_CONFIG_FILENAME: () => AWS_CLOUD_CONFIG_FILENAME,
+  BOTONIC_HOME_DIRNAME: () => BOTONIC_HOME_DIRNAME,
+  BOTONIC_NPM_NAMESPACE: () => BOTONIC_NPM_NAMESPACE,
+  BOTONIC_PROJECT_PATH: () => BOTONIC_PROJECT_PATH,
+  BOT_CREDENTIALS_FILENAME: () => BOT_CREDENTIALS_FILENAME,
+  CLOUD_PROVIDERS: () => CLOUD_PROVIDERS,
+  GLOBAL_CREDS_FILENAME: () => GLOBAL_CREDS_FILENAME,
+  LOCAL_RUNTIME_BOT_CREDENTIALS_FILENAME: () => LOCAL_RUNTIME_BOT_CREDENTIALS_FILENAME,
+  PATH_TO_AWS_CONFIG: () => PATH_TO_AWS_CONFIG
+});
+module.exports = __toCommonJS(constants_exports);
+var import_path = require("path");
+var import_process = require("process");
+const BOTONIC_NPM_NAMESPACE = "@botonic";
+const BOTONIC_HOME_DIRNAME = ".botonic";
+const GLOBAL_CREDS_FILENAME = "credentials.json";
+const BOTONIC_PROJECT_PATH = process.cwd();
+const BOT_CREDENTIALS_FILENAME = ".botonic.json";
+const LOCAL_RUNTIME_BOT_CREDENTIALS_FILENAME = ".local-runtime-botonic.json";
+const ANALYTICS_WRITE_KEY = "YD0jpJHNGW12uhLNbgB4wbdTRQ4Cy1Zu";
+const CLOUD_PROVIDERS = Object.freeze({
+  AWS: "aws",
+  HUBTYPE: "hubtype"
+});
+const AWS_CLOUD_CONFIG_FILENAME = "aws.config.js";
+const PATH_TO_AWS_CONFIG = (0, import_path.join)((0, import_process.cwd)(), AWS_CLOUD_CONFIG_FILENAME);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ANALYTICS_WRITE_KEY,
+  AWS_CLOUD_CONFIG_FILENAME,
+  BOTONIC_HOME_DIRNAME,
+  BOTONIC_NPM_NAMESPACE,
+  BOTONIC_PROJECT_PATH,
+  BOT_CREDENTIALS_FILENAME,
+  CLOUD_PROVIDERS,
+  GLOBAL_CREDS_FILENAME,
+  LOCAL_RUNTIME_BOT_CREDENTIALS_FILENAME,
+  PATH_TO_AWS_CONFIG
+});

package/src/lib/credentials-handler.d.ts

@@ -0,0 +1,40 @@
+import type { BotCredentials, GlobalCredentialsStore, JSONObject } from './interfaces';
+export declare class CredentialsHandler {
+    homeDir: string;
+    pathToCredentials: string;
+    constructor(args: {
+        homeDir: string;
+        filename: string;
+    });
+    initialize(): void;
+    createDirIfNotExists(): void;
+    loadJSON(): JSONObject | undefined;
+    dumpJSON(obj: JSONObject): void;
+}
+export declare class GlobalCredentialsHandler extends CredentialsHandler {
+    /**
+     * @param baseDir - Optional directory for credentials (e.g. monorepo_root/.botonic).
+     * When provided, credentials are stored at baseDir/credentials.json (source of truth in monorepo).
+     * When omitted, uses ~/.botonic (user home).
+     */
+    constructor(baseDir?: string);
+    initialize(): void;
+    load(): GlobalCredentialsStore | undefined;
+    dump(obj: GlobalCredentialsStore): void;
+}
+declare class BaseBotCredentialsHandler<T> extends CredentialsHandler {
+    constructor(args: {
+        homeDir: string;
+        filename: string;
+    });
+    load(): T | undefined;
+    dump(obj: T): void;
+}
+export declare class BotCredentialsHandler extends BaseBotCredentialsHandler<BotCredentials> {
+    /**
+     * @param projectRoot - Directory for app/project .botonic.json (e.g. apps/my-bot).
+     * When omitted, uses process.cwd() (may write to repo root when Nx cwd is workspace root).
+     */
+    constructor(projectRoot?: string);
+}
+export {};

package/src/lib/credentials-handler.js

@@ -0,0 +1,115 @@
+"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 credentials_handler_exports = {};
+__export(credentials_handler_exports, {
+  BotCredentialsHandler: () => BotCredentialsHandler,
+  CredentialsHandler: () => CredentialsHandler,
+  GlobalCredentialsHandler: () => GlobalCredentialsHandler
+});
+module.exports = __toCommonJS(credentials_handler_exports);
+var import_path = require("path");
+var import_constants = require("./constants");
+var import_file_system = require("./util/file-system");
+class CredentialsHandler {
+  constructor(args) {
+    this.homeDir = (0, import_path.resolve)(args.homeDir);
+    this.pathToCredentials = (0, import_path.join)(this.homeDir, args.filename);
+    this.initialize();
+  }
+  initialize() {
+    this.createDirIfNotExists();
+  }
+  createDirIfNotExists() {
+    if (!(0, import_file_system.pathExists)(this.homeDir)) (0, import_file_system.createDir)(this.homeDir);
+  }
+  loadJSON() {
+    try {
+      if (!(0, import_file_system.pathExists)(this.pathToCredentials)) return void 0;
+      return (0, import_file_system.readJSON)(this.pathToCredentials);
+    } catch (e) {
+      console.warn("Credentials could not be loaded");
+      return void 0;
+    }
+  }
+  dumpJSON(obj) {
+    try {
+      (0, import_file_system.writeJSON)(this.pathToCredentials, obj);
+    } catch (e) {
+      console.warn("Credentials could not be overwritten");
+    }
+  }
+}
+class GlobalCredentialsHandler extends CredentialsHandler {
+  /**
+   * @param baseDir - Optional directory for credentials (e.g. monorepo_root/.botonic).
+   * When provided, credentials are stored at baseDir/credentials.json (source of truth in monorepo).
+   * When omitted, uses ~/.botonic (user home).
+   */
+  constructor(baseDir) {
+    super({
+      homeDir: baseDir ? (0, import_path.resolve)(baseDir) : (0, import_path.join)((0, import_file_system.getHomeDirectory)(), import_constants.BOTONIC_HOME_DIRNAME),
+      filename: import_constants.GLOBAL_CREDS_FILENAME
+    });
+  }
+  initialize() {
+    this.createDirIfNotExists();
+  }
+  load() {
+    const json = this.loadJSON();
+    if (!json) return void 0;
+    return json;
+  }
+  dump(obj) {
+    return this.dumpJSON(obj);
+  }
+}
+class BaseBotCredentialsHandler extends CredentialsHandler {
+  constructor(args) {
+    super({
+      homeDir: args.homeDir,
+      filename: args.filename
+    });
+  }
+  load() {
+    const json = this.loadJSON();
+    if (!json) return void 0;
+    return json;
+  }
+  dump(obj) {
+    return this.dumpJSON(obj);
+  }
+}
+class BotCredentialsHandler extends BaseBotCredentialsHandler {
+  /**
+   * @param projectRoot - Directory for app/project .botonic.json (e.g. apps/my-bot).
+   * When omitted, uses process.cwd() (may write to repo root when Nx cwd is workspace root).
+   */
+  constructor(projectRoot) {
+    super({
+      homeDir: projectRoot ? (0, import_path.resolve)(projectRoot) : import_constants.BOTONIC_PROJECT_PATH,
+      filename: import_constants.BOT_CREDENTIALS_FILENAME
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotCredentialsHandler,
+  CredentialsHandler,
+  GlobalCredentialsHandler
+});

package/src/lib/index.d.ts

@@ -0,0 +1,10 @@
+export { BotonicAPIService } from './api-service';
+export * from './bot-config';
+export * from './cloudflared-tunnel';
+export * from './constants';
+export * from './credentials-handler';
+export * from './interfaces';
+export * from './util/executor-helpers';
+export * from './util/file-system';
+export * from './util/sam-template';
+export * from './util/system';

package/src/lib/index.js

@@ -0,0 +1,47 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_exports = {};
+__export(lib_exports, {
+  BotonicAPIService: () => import_api_service.BotonicAPIService
+});
+module.exports = __toCommonJS(lib_exports);
+var import_api_service = require("./api-service");
+__reExport(lib_exports, require("./bot-config"), module.exports);
+__reExport(lib_exports, require("./cloudflared-tunnel"), module.exports);
+__reExport(lib_exports, require("./constants"), module.exports);
+__reExport(lib_exports, require("./credentials-handler"), module.exports);
+__reExport(lib_exports, require("./interfaces"), module.exports);
+__reExport(lib_exports, require("./util/executor-helpers"), module.exports);
+__reExport(lib_exports, require("./util/file-system"), module.exports);
+__reExport(lib_exports, require("./util/sam-template"), module.exports);
+__reExport(lib_exports, require("./util/system"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotonicAPIService,
+  ...require("./bot-config"),
+  ...require("./cloudflared-tunnel"),
+  ...require("./constants"),
+  ...require("./credentials-handler"),
+  ...require("./interfaces"),
+  ...require("./util/executor-helpers"),
+  ...require("./util/file-system"),
+  ...require("./util/sam-template"),
+  ...require("./util/system")
+});

package/src/lib/interfaces.d.ts

@@ -0,0 +1,49 @@
+export interface OAuth {
+    access_token: string;
+    expires_in: number;
+    token_type: string;
+    scope: string;
+    refresh_token: string;
+}
+export interface Me {
+    id: string;
+    email: string;
+    first_name: string;
+    last_name: string;
+    organization_id: string;
+    campaign: string;
+}
+/** Credentials for a single environment (local, dev, prod, etc.). */
+export interface EnvironmentCredentials {
+    oauth?: OAuth;
+    me?: Me;
+    /** User display name when logged in (for display when me is not loaded yet). */
+    loggedUserName?: string;
+    /** Hubtype API URL for this environment (to detect env switch). */
+    loggedEnvironmentUrl?: string;
+}
+/** Store: one entry per environment so multiple envs can be logged in. */
+export type GlobalCredentialsStore = Record<string, EnvironmentCredentials>;
+export interface BotDetail {
+    id: string;
+    name: string;
+    organization: string;
+    last_update: any;
+    created_at: string;
+    provider_accounts: any[];
+    is_debug: boolean;
+    is_published: boolean;
+    active_users: number;
+}
+export interface BotCredentials {
+    bot: BotDetail | null;
+}
+export interface LocalRuntimeBotCredentials {
+    localRuntimeBot: BotDetail | null;
+}
+export type JSONPrimitive = string | number | boolean | null;
+export type JSONValue = JSONPrimitive | JSONObject | JSONArray;
+export type JSONObject = {
+    [member: string]: JSONValue;
+};
+export type JSONArray = JSONValue[];

package/src/lib/interfaces.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 interfaces_exports = {};
+module.exports = __toCommonJS(interfaces_exports);