@botonic/nx-plugin 2.23.0

package/src/lib/api-service.js

@@ -0,0 +1,591 @@
+"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 api_service_exports = {};
+__export(api_service_exports, {
+  BotonicAPIService: () => BotonicAPIService
+});
+module.exports = __toCommonJS(api_service_exports);
+var import_axios = __toESM(require("axios"));
+var import_child_process = require("child_process");
+var import_fs = require("fs");
+var import_fs_extra = require("fs-extra");
+var import_path = require("path");
+var import_qs = require("qs");
+var import_constants = require("./constants");
+var import_credentials_handler = require("./credentials-handler");
+var import_file_system = require("./util/file-system");
+const FormData = require("form-data");
+const BOTONIC_CLIENT_ID = process.env["VITE_HUBTYPE_CLIENT_ID"] || "";
+const BOTONIC_URL = process.env["VITE_HUBTYPE_API_URL"] || "";
+const resolveEnvironment = (environmentVariables) => {
+  return {
+    hubtypeClientId: environmentVariables["VITE_HUBTYPE_CLIENT_ID"],
+    hubtypeApiUrl: environmentVariables["VITE_HUBTYPE_API_URL"]
+  };
+};
+class BotonicAPIService {
+  constructor(config = {
+    isLocalRuntimeDeployment: false,
+    projectRoot: void 0,
+    environmentVariables: {},
+    targetEnvironment: "local"
+  }) {
+    this.clientId = BOTONIC_CLIENT_ID;
+    this.baseUrl = BOTONIC_URL;
+    this.loginUrl = BOTONIC_URL + "/o/token/";
+    this.bot = null;
+    this.localRuntimeBot = null;
+    this.headers = new import_axios.AxiosHeaders();
+    const { hubtypeClientId, hubtypeApiUrl } = resolveEnvironment(
+      config.environmentVariables || {}
+    );
+    this.clientId = hubtypeClientId;
+    this.baseUrl = hubtypeApiUrl;
+    this.loginUrl = hubtypeApiUrl + "/o/token/";
+    this.globalCredentialsHandler = config.workspaceRoot != null ? new import_credentials_handler.GlobalCredentialsHandler(
+      (0, import_path.join)(config.workspaceRoot, import_constants.BOTONIC_HOME_DIRNAME)
+    ) : new import_credentials_handler.GlobalCredentialsHandler();
+    this.botCredentialsHandler = new import_credentials_handler.BotCredentialsHandler(config.projectRoot);
+    this.isLocalRuntimeDeployment = config.isLocalRuntimeDeployment;
+    this.projectRoot = config.projectRoot;
+    this.targetEnvironment = config.targetEnvironment;
+    this.loadGlobalCredentials();
+    this.loadBotCredentials();
+    this.setHeaders(this.oauth?.access_token);
+    if (this.isLocalRuntimeDeployment && this.projectRoot) {
+      try {
+        const appBotPath = (0, import_path.join)(this.projectRoot, import_constants.BOT_CREDENTIALS_FILENAME);
+        if ((0, import_fs.existsSync)(appBotPath)) {
+          const appCreds = (0, import_file_system.readJSON)(appBotPath);
+          if (appCreds?.bot) {
+            this.localRuntimeBot = appCreds.bot;
+          }
+        }
+      } catch {
+      }
+    }
+    this.apiClient = import_axios.default.create({
+      baseURL: this.baseUrl
+      // Remove headers from here - we'll pass them explicitly in each request
+    });
+    const onFullfilled = (response) => {
+      return response;
+    };
+    const onRejected = async (error) => {
+      const originalRequest = error.config;
+      const retry = originalRequest?._retry;
+      if (error.response?.status === 401 && !retry) {
+        console.log("Token expired. Refreshing token...");
+        originalRequest._retry = true;
+        try {
+          await this.refreshToken();
+          const nextRequest = {
+            ...originalRequest,
+            headers: {
+              ...originalRequest.headers,
+              ...this.headers
+            }
+          };
+          console.log("Token refreshed, retrying request...");
+          return this.apiClient.request(nextRequest);
+        } catch (refreshError) {
+          console.error("Token refresh failed:", refreshError);
+          await this.logout();
+          return Promise.reject(
+            new Error("Authentication failed. Please login again.")
+          );
+        }
+      }
+      return Promise.reject(error);
+    };
+    this.apiClient.interceptors.response.use(onFullfilled, onRejected);
+  }
+  saveAllCredentials() {
+    this.saveGlobalCredentials();
+    if (!this.isLocalRuntimeDeployment) {
+      this.saveBotCredentials();
+    }
+  }
+  botInfo() {
+    if (this.isLocalRuntimeDeployment) {
+      if (!this.localRuntimeBot) {
+        throw new Error("Not local runtime bot info available");
+      }
+      return this.localRuntimeBot;
+    } else {
+      if (!this.bot) {
+        throw new Error("Not bot info available");
+      }
+      return this.bot;
+    }
+  }
+  getOauth() {
+    if (!this.oauth) {
+      throw new Error("Not authenticated");
+    }
+    return this.oauth;
+  }
+  isAuthenticated() {
+    return !!this.oauth?.access_token;
+  }
+  /** True when in local runtime mode and a bot was loaded (e.g. from app .botonic.json). */
+  hasLocalRuntimeBot() {
+    return Boolean(this.isLocalRuntimeDeployment && this.localRuntimeBot);
+  }
+  async ensureAuthenticated() {
+    if (!this.isAuthenticated()) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    const isValid = await this.validateToken();
+    if (!isValid) {
+      try {
+        await this.refreshToken();
+      } catch (error) {
+        throw new Error("Authentication expired. Please login again.");
+      }
+    }
+  }
+  setCurrentBot(bot) {
+    this.bot = bot;
+  }
+  setLocalRuntimeBot(bot) {
+    this.localRuntimeBot = bot;
+  }
+  loadGlobalCredentials() {
+    const store = this.normalizeCredentialsStore(
+      this.globalCredentialsHandler.load()
+    );
+    if (!store) return;
+    const env = this.targetEnvironment ?? "local";
+    const creds = store[env];
+    if (creds) {
+      this.oauth = creds.oauth;
+      this.me = creds.me;
+      this.loggedUserName = creds.loggedUserName;
+      this.loggedEnvironmentUrl = creds.loggedEnvironmentUrl;
+    }
+  }
+  /**
+   * Returns store as env -> credentials. Migrates old single-credential format to { local: creds }.
+   */
+  normalizeCredentialsStore(store) {
+    if (!store) return void 0;
+    const raw = store;
+    if (raw.oauth != null && typeof raw.oauth === "object") {
+      return { local: raw };
+    }
+    return store;
+  }
+  loadBotCredentials() {
+    const credentials = this.botCredentialsHandler.load();
+    if (credentials?.bot) {
+      this.bot = credentials.bot;
+    }
+  }
+  setHeaders(accessToken) {
+    if (accessToken) {
+      this.headers.set("Authorization", `Bearer ${accessToken}`);
+    } else {
+      this.headers.delete("Authorization");
+    }
+  }
+  saveGlobalCredentials() {
+    const env = this.targetEnvironment ?? "local";
+    const loggedUserName = this.me?.email ?? this.loggedUserName;
+    const store = this.normalizeCredentialsStore(this.globalCredentialsHandler.load()) ?? {};
+    store[env] = {
+      oauth: this.oauth,
+      me: this.me,
+      loggedUserName: loggedUserName ?? void 0,
+      loggedEnvironmentUrl: this.baseUrl ? this.baseUrl : void 0
+    };
+    this.globalCredentialsHandler.dump(store);
+  }
+  saveBotCredentials() {
+    this.botCredentialsHandler.dump({
+      bot: this.bot
+    });
+  }
+  async refreshToken() {
+    if (!this.oauth?.refresh_token) {
+      throw new Error("No refresh token available");
+    }
+    const data = (0, import_qs.stringify)({
+      callback: "none",
+      grant_type: "refresh_token",
+      refresh_token: this.oauth.refresh_token,
+      client_id: this.clientId
+    });
+    try {
+      const oauthResponse = await import_axios.default.post(this.loginUrl, data, {
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded"
+        }
+      });
+      if (oauthResponse.status !== 200) {
+        throw new Error(
+          `Token refresh failed with status: ${oauthResponse.status}`
+        );
+      }
+      if (!oauthResponse.data?.access_token) {
+        throw new Error("Invalid token refresh response: missing access_token");
+      }
+      this.oauth = oauthResponse.data;
+      const accessToken = this.getOauth().access_token;
+      this.setHeaders(accessToken);
+      this.saveGlobalCredentials();
+      console.log("Token refreshed successfully");
+    } catch (error) {
+      console.error("Token refresh error:", error.message);
+      throw new Error(`Failed to refresh token: ${error.message}`);
+    }
+  }
+  async login(email, password) {
+    const data = (0, import_qs.stringify)({
+      username: email,
+      password,
+      grant_type: "password",
+      client_id: this.clientId
+    });
+    const loginResponse = await import_axios.default.post(this.loginUrl, data, {
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+    this.oauth = loginResponse.data;
+    const accessToken = this.getOauth().access_token;
+    this.setHeaders(accessToken);
+    try {
+      const meRes = await this.getMe();
+      this.me = meRes.data;
+    } catch {
+    }
+    this.saveGlobalCredentials();
+  }
+  async logout() {
+    const pathToCredentials = this.globalCredentialsHandler.pathToCredentials;
+    if (await (0, import_fs_extra.pathExists)(pathToCredentials)) {
+      (0, import_fs.rmSync)(pathToCredentials, { force: true });
+    } else {
+      console.log("Already logged out...\n");
+    }
+    this.oauth = void 0;
+    this.me = void 0;
+    this.loggedUserName = void 0;
+    this.loggedEnvironmentUrl = void 0;
+    this.bot = null;
+    this.localRuntimeBot = null;
+    this.headers.delete("Authorization");
+  }
+  /**
+   * Ensures me is loaded (for display). Call before showing "Working as ...".
+   */
+  async ensureMeLoaded() {
+    if (this.oauth && !this.me) {
+      try {
+        const meRes = await this.getMe();
+        this.me = meRes.data;
+        this.saveGlobalCredentials();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Display name for the logged-in user (for "Working as X in environment ...").
+   */
+  getDisplayName() {
+    if (this.me?.email) return this.me.email;
+    return this.loggedUserName ?? "Unknown";
+  }
+  async createWebchatIntegration(botId, integrationName) {
+    return this.apiPost({
+      apiVersion: "v1",
+      path: `provider_accounts/connect_webchat_channel/`,
+      body: { botId, name: integrationName, settings: {} }
+    });
+  }
+  async signup(email, password, orgName, campaign) {
+    const signupData = { email, password, org_name: orgName, campaign };
+    return this.apiPost({ path: "sign-up/", body: signupData });
+  }
+  async createBot(botName) {
+    const resp = await this.apiPost({
+      apiVersion: "v2",
+      path: "bots/",
+      body: { name: botName }
+    });
+    if (this.isLocalRuntimeDeployment) {
+      this.setLocalRuntimeBot(resp.data);
+    } else {
+      this.setCurrentBot(resp.data);
+    }
+    return resp;
+  }
+  async getBots() {
+    return this.apiGet({
+      apiVersion: "v2",
+      path: "bots/?page_size=100"
+    });
+  }
+  async deleteBot(botId) {
+    return this.apiDelete({
+      apiVersion: "v2",
+      path: `bots/${botId}/`
+    });
+  }
+  async getProviders(botId) {
+    return this.apiGet({
+      path: "provider_accounts/",
+      params: {
+        bot_id: botId || this.botInfo().id
+      }
+    });
+  }
+  async deployBot(bundlePath, botConfigJson) {
+    try {
+      await this.getMe();
+    } catch (e) {
+      console.log(`Error authenticating: ${String(e)}`);
+    }
+    const form = new FormData();
+    const data = (0, import_fs.createReadStream)(bundlePath);
+    form.append("bundle", data, "botonic_bundle.zip");
+    form.append("bot_config", JSON.stringify(botConfigJson));
+    form.append("deployment_strategy", "botonic_v2");
+    const headers = await this.getHeaders(form);
+    return await this.apiPost({
+      apiVersion: "v2",
+      path: `bots/${this.botInfo().id}/deploy/`,
+      body: form,
+      headers: {
+        ...this.headers,
+        ...headers
+      }
+    });
+  }
+  async deployStatus(deployId) {
+    return this.apiGet({
+      apiVersion: "v2",
+      path: `bots/${this.botInfo().id}/deploy_status/`,
+      params: { deploy_id: deployId }
+    });
+  }
+  async deployLocalRuntime({
+    botConfigJson,
+    lambdaFunctionName,
+    lambdaEndpoint
+  }) {
+    try {
+      await this.getMe();
+    } catch (e) {
+      console.log(`Error authenticating: ${String(e)}`);
+    }
+    const form = new FormData();
+    form.append("bot_config", JSON.stringify(botConfigJson));
+    form.append("lambda_function_name", lambdaFunctionName);
+    form.append("lambda_endpoint", lambdaEndpoint);
+    const headers = await this.getHeaders(form);
+    return await this.apiPost({
+      apiVersion: "v2",
+      path: `bots/${this.botInfo().id}/deploy_local_runtime/`,
+      body: form,
+      headers: {
+        ...this.headers,
+        ...headers
+      }
+    });
+  }
+  async build({
+    projectRoot,
+    projectName
+  }) {
+    try {
+      console.log("Building...");
+      (0, import_fs.rm)((0, import_path.join)(projectRoot, "dist"), { recursive: true, force: true }, (err) => {
+        if (err) {
+          console.error("Error removing dist directory", err);
+        }
+      });
+      const commands = [
+        [
+          "run",
+          `${projectName}:build-webchat-app`,
+          `--configuration=${this.targetEnvironment}`
+        ],
+        [
+          "run",
+          `${projectName}:build-webviews-app`,
+          `--configuration=${this.targetEnvironment}`
+        ],
+        [
+          "run",
+          `${projectName}:build-node-app`,
+          `--configuration=${this.targetEnvironment}`
+        ]
+      ];
+      const processes = commands.map(
+        (cmd) => new Promise((resolve, reject) => {
+          const childProcess = (0, import_child_process.spawn)("nx", cmd, {
+            cwd: process.cwd(),
+            stdio: "inherit"
+          });
+          childProcess.on("close", (code) => {
+            resolve(code === 0);
+          });
+          childProcess.on("error", (error) => {
+            reject(error);
+          });
+        })
+      );
+      const results = await Promise.all(processes);
+      await this.prepareLambda(projectRoot);
+      return results.every((result) => result === true);
+    } catch (error) {
+      console.log("\n\nBuild error:\n", error);
+      return false;
+    }
+  }
+  async prepareLambda(projectRoot) {
+    try {
+      (0, import_child_process.execSync)(
+        `mkdir -p ${projectRoot}/dist/lambda && cp -r ${projectRoot}/src/server/lambda/* ${projectRoot}/dist/lambda/ && cd ${projectRoot}/dist/lambda && npm install`
+      );
+      return true;
+    } catch (error) {
+      console.log("\n\nPrepare Lambda error:\n", error);
+      return false;
+    }
+  }
+  async apiPost({
+    apiVersion = "v1",
+    path,
+    body,
+    headers,
+    params
+  }) {
+    if (this.oauth?.access_token && this.isTokenExpired()) {
+      try {
+        await this.refreshToken();
+      } catch (error) {
+        console.warn(
+          "Proactive token refresh failed, proceeding with request:",
+          error
+        );
+      }
+    }
+    return this.apiClient.post(
+      `${this.baseUrl}/${apiVersion}/${path}`,
+      body,
+      {
+        headers: headers || this.headers,
+        params
+      }
+    );
+  }
+  async apiGet({
+    apiVersion = "v1",
+    path,
+    headers,
+    params
+  }) {
+    if (this.oauth?.access_token && this.isTokenExpired()) {
+      try {
+        await this.refreshToken();
+      } catch (error) {
+        console.warn(
+          "Proactive token refresh failed, proceeding with request:",
+          error
+        );
+      }
+    }
+    return this.apiClient.get(`${this.baseUrl}/${apiVersion}/${path}`, {
+      headers: headers || this.headers,
+      params
+    });
+  }
+  async apiDelete({
+    apiVersion = "v1",
+    path,
+    headers,
+    params
+  }) {
+    if (this.oauth?.access_token && this.isTokenExpired()) {
+      try {
+        await this.refreshToken();
+      } catch (error) {
+        console.warn(
+          "Proactive token refresh failed, proceeding with request:",
+          error
+        );
+      }
+    }
+    return this.apiClient.delete(`${this.baseUrl}/${apiVersion}/${path}`, {
+      headers: headers || this.headers,
+      params
+    });
+  }
+  async getMe() {
+    return this.apiClient.get("/v3/users/me/");
+  }
+  async validateToken() {
+    try {
+      await this.getMe();
+      return true;
+    } catch (error) {
+      if (error.response?.status === 401) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  isTokenExpired() {
+    if (!this.oauth?.access_token) {
+      return true;
+    }
+    return false;
+  }
+  async getHeaders(form) {
+    return new Promise((resolve, reject) => {
+      form.getLength((err, length) => {
+        if (err) {
+          reject(err);
+        }
+        const headers = Object.assign(
+          { "Content-Length": length },
+          form.getHeaders()
+        );
+        resolve(headers);
+      });
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BotonicAPIService
+});

package/src/lib/bot-config.d.ts

@@ -0,0 +1,30 @@
+export interface BotConfigJSON {
+    build_info: {
+        node_version: string;
+        npm_version: string;
+        botonic_cli_version: string;
+    };
+    packages: Record<string, {
+        version: string;
+    }>;
+    tools: Array<{
+        name: string;
+        description: string;
+    }>;
+    payloads: string[];
+    webviews: Array<{
+        name: string;
+    }>;
+}
+export declare class BotConfig {
+    static get(projectRoot: string): Promise<BotConfigJSON>;
+    private static displayBotConfig;
+    private static loadBotConfig;
+    private static getTools;
+    private static loadModuleConstant;
+    private static getPayloads;
+    private static getWebviews;
+    private static getBuildInfo;
+    private static getBotonicPackages;
+    private static getOutputByCommand;
+}