/*****************************************************************************\ | █████ █████ ██ █ █████ █████ ████ ██ ████ █████ █████ ███ ® | | ██ █ ███ █ █ ██ ██ ██ ██ ██ ██ █ ██ ██ █ █ | | ██ ███ ████ █ ██ █ ████ █████ ██████ ██ ████ █ █ █ ██ | | ██ ██ █ █ ██ █ █ ██ ██ ██ ██ ██ ██ █ ██ ██ █ █ | | █████ █████ █ ███ █████ ██ ██ ██ ██ █████ ████ █████ █ ███ | | | | General Bots Copyright (c) pragmatismo.cloud. All rights reserved. | | Licensed under the AGPL-3.0. | | | | According to our dual licensing model, this program can be used either | | under the terms of the GNU Affero General Public License, version 3, | | or under a proprietary license. | | | | The texts of the GNU Affero General Public License with an additional | | permission and of our proprietary license can be found at and | | in the LICENSE file you have received along with this program. | | | | This program is distributed in the hope that it will be useful, | | but WITHOUT ANY WARRANTY, without even the implied warranty of | | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | | GNU Affero General Public License for more details. | | | | "General Bots" is a registered trademark of pragmatismo.cloud. | | The licensing of the program under the AGPLv3 does not imply a | | trademark license. Therefore any rights, title and interest in | | our trademarks remain entirely with us. | | | \*****************************************************************************/ /** * @fileoverview General Bots server core. */ 'use strict'; import { createRpcServer } from '@push-rpc/core'; import AuthenticationContext from 'adal-node'; import arrayBufferToBuffer from 'arraybuffer-to-buffer'; import { watch } from 'fs'; import debounce from 'lodash.debounce'; import chokidar from 'chokidar'; import { AutoSaveStateMiddleware, BotFrameworkAdapter, ConversationState, MemoryStorage, TurnContext, UserState } from 'botbuilder'; import { FacebookAdapter } from 'botbuilder-adapter-facebook'; import { AttachmentPrompt, ConfirmPrompt, DialogSet, OAuthPrompt, TextPrompt, WaterfallDialog } from 'botbuilder-dialogs'; import { MicrosoftAppCredentials } from 'botframework-connector'; import { GBDialogStep, GBLog, GBMinInstance, IGBAdminService, IGBConversationalService, IGBCoreService, IGBInstance, IGBPackage } from 'botlib'; import cliProgress from 'cli-progress'; import removeRoute from 'express-remove-route'; import fs from 'fs/promises'; import Koa from 'koa'; import mkdirp from 'mkdirp'; import { NlpManager } from 'node-nlp'; import path from 'path'; import { CollectionUtil } from 'pragmatismo-io-framework'; import SwaggerClient from 'swagger-client'; import urlJoin from 'url-join'; import wash from 'washyourmouthoutwithsoap'; import { v2 as webdav } from 'webdav-server'; import { start as startRouter } from '../../../packages/core.gbapp/services/router/bridge.js'; import { GBServer } from '../../../src/app.js'; import { GBUtil } from '../../../src/util.js'; import { GBAdminService } from '../../admin.gbapp/services/GBAdminService.js'; import { GuaribasConversationMessage } from '../../analytics.gblib/models/index.js'; import { AnalyticsService } from '../../analytics.gblib/services/AnalyticsService.js'; import { createKoaHttpServer } from '../../basic.gblib/index.js'; import { DebuggerService } from '../../basic.gblib/services/DebuggerService.js'; import { DialogKeywords } from '../../basic.gblib/services/DialogKeywords.js'; import { GBVMService } from '../../basic.gblib/services/GBVMService.js'; import { ImageProcessingServices } from '../../basic.gblib/services/ImageProcessingServices.js'; import { ScheduleServices } from '../../basic.gblib/services/ScheduleServices.js'; import { SystemKeywords } from '../../basic.gblib/services/SystemKeywords.js'; import { WebAutomationServices } from '../../basic.gblib/services/WebAutomationServices.js'; import { GoogleChatDirectLine } from '../../google-chat.gblib/services/GoogleChatDirectLine.js'; import { AskDialogArgs } from '../../kb.gbapp/dialogs/AskDialog.js'; import { KBService } from '../../kb.gbapp/services/KBService.js'; import { SecService } from '../../security.gbapp/services/SecService.js'; import { WhatsappDirectLine } from '../../whatsapp.gblib/services/WhatsappDirectLine.js'; import { Messages } from '../strings.js'; import { GBConfigService } from './GBConfigService.js'; import { GBConversationalService } from './GBConversationalService.js'; import { GBDeployer } from './GBDeployer.js'; import { GBLogEx } from './GBLogEx.js'; import { GBSSR } from './GBSSR.js'; /** * Minimal service layer for a bot and encapsulation of BOT Framework calls. */ export class GBMinService { /** * Default General Bots User Interface package. */ public static uiPackage = 'default.gbui'; /** * Main core service attached to this bot service. */ public core: IGBCoreService; /** * Reference to conversation services like receive and prompt text. */ public conversationalService: IGBConversationalService; /** * Conversational administration services like publishing packages. */ public adminService: IGBAdminService; /** * Deployent of packages and publishing related services. */ public deployer: GBDeployer; bar1; /** * Static initialization of minimal instance. */ constructor( core: IGBCoreService, conversationalService: IGBConversationalService, adminService: IGBAdminService, deployer: GBDeployer ) { this.core = core; this.conversationalService = conversationalService; this.adminService = adminService; this.deployer = deployer; } public async enableAPI(min: GBMinInstance) {} /** * Constructs a new minimal instance for each bot. */ public async buildMin(instances: IGBInstance[]): Promise { // Servers default UI on root address '/' if web enabled. if (process.env.DISABLE_WEB !== 'true') { // SSR processing and default.gbui access definition. GBServer.globals.server.get('/', async (req, res, next) => { await GBSSR.ssrFilter(req, res, next); }); // Servers the bot information object via HTTP so clients can get // instance information stored on server. GBServer.globals.server.get('/instances/:botId', this.handleGetInstanceForClient.bind(this)); } // Calls mountBot event to all bots. let i = 1; const minInstances = []; await CollectionUtil.asyncForEach( instances, (async instance => { try { GBLog.info(`Mounting ${instance.botId}...`); const min = await this['mountBot'](instance); minInstances.push(min); } catch (error) { GBLog.error(`Error mounting bot ${instance.botId}: ${error.message}\n${error.stack}`); } }).bind(this) ); // Loads schedules. GBLogEx.info(0, `Loading SET SCHEDULE entries...`); const service = new ScheduleServices(); await service.scheduleAll(); GBLogEx.info(0, `All Bot service instances loaded.`); return minInstances; } public async startSimpleTest(min) { if (process.env.TEST_MESSAGE && min['isDefault']) { GBLogEx.info(min, `Starting auto test with '${process.env.TEST_MESSAGE}'.`); const client = await GBUtil.getDirectLineClient(min); const response = await client.apis.Conversations.Conversations_StartConversation(); const conversationId = response.obj.conversationId; GBServer.globals.debugConversationId = conversationId; const steps = process.env.TEST_MESSAGE.split(';'); await CollectionUtil.asyncForEach(steps, async step => { client.apis.Conversations.Conversations_PostActivity({ conversationId: conversationId, activity: { textFormat: 'plain', text: step, type: 'message', from: { id: 'test', name: 'test' } } }); await GBUtil.sleep(3000); }); } } /** * Removes bot endpoint from web listeners and remove bot instance * from list of global server bot instances. */ public async unmountBot(botId: string) { const url = `/api/messages/${botId}`; removeRoute(GBServer.globals.server, url); const uiUrl = `/${botId}`; removeRoute(GBServer.globals.server, uiUrl); GBServer.globals.minInstances = GBServer.globals.minInstances.filter(p => p.instance.botId !== botId); } /** * Mount the bot web site (default.gbui) secure domain. */ public async loadDomain(min: GBMinInstance) { // TODO: https://github.com/GeneralBots/BotServer/issues/321 const options = { passphrase: process.env.CERTIFICATE2_PASSPHRASE, pfx: await fs.readFile(process.env.CERTIFICATE2_PFX) }; const domain = min.core.getParam(min.instance, 'Domain', null); if (domain) { GBServer.globals.server.get(domain, async (req, res, next) => { await GBSSR.ssrFilter(req, res, next); }); GBLog.verbose(`Bot UI ${GBMinService.uiPackage} accessible at custom domain: ${domain}.`); } GBServer.globals.httpsServer.addContext(process.env.CERTIFICATE2_DOMAIN, options); } /** * Unmounts the bot web site (default.gbui) secure domain, if any. */ public async unloadDomain(instance: IGBInstance) {} /** * Mount the instance by creating an BOT Framework bot object, * serving bot endpoint in several URL like WhatsApp endpoint, .gbkb assets, * installing all BASIC artifacts from .gbdialog and OAuth2. */ public async mountBot(instance: IGBInstance) { // Build bot adapter. const { min, adapter, conversationState } = await this.buildBotAdapter( instance, GBServer.globals.sysPackages, GBServer.globals.appPackages ); // https://github.com/GeneralBots/BotServer/issues/286 // min['groupCache'] = await KBService.getGroupReplies(instance.instanceId); min['isDefault'] = GBServer.globals.minInstances.length === 0; GBServer.globals.minInstances.push(min); const user = null; // No user context. await GBVMService.loadConnections(min); // Serves individual URL for each bot conversational interface. await this.deployer['deployPackage2'](min, user, 'templates/default.gbai/default.gbtheme'); // Install per bot deployed packages. let packagePath = urlJoin(`work`, GBUtil.getGBAIPath(min.botId, 'gbdialog')); if (await GBUtil.exists(packagePath)) { await this.deployer['deployPackage2'](min, user, packagePath); } packagePath = urlJoin(`work`, GBUtil.getGBAIPath(min.botId, 'gbapp')); if (await GBUtil.exists(packagePath)) { await this.deployer['deployPackage2'](min, user, packagePath); } packagePath = urlJoin(`work`, GBUtil.getGBAIPath(min.botId, 'gbtheme')); if (await GBUtil.exists(packagePath)) { await this.deployer['deployPackage2'](min, user, packagePath); } packagePath = urlJoin(`work`, GBUtil.getGBAIPath(min.botId, `gblib`)); if (await GBUtil.exists(packagePath)) { await this.deployer['deployPackage2'](min, user, packagePath); } const gbai = GBUtil.getGBAIPath(min.botId); let dir = `work/${gbai}/cache`; const botId = gbai.replace(/\.[^/.]+$/, ''); if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } dir = `work/${gbai}/profile`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } dir = `work/${gbai}/uploads`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } dir = `work/${gbai}/${botId}.gbkb`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } await this.watchPackages(min, 'gbkb'); dir = `work/${gbai}/${botId}.gbkb/docs-vectorized`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } dir = `work/${gbai}/${botId}.gbdialog`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } await this.watchPackages(min, 'gbdialog'); dir = `work/${gbai}/${botId}.gbot`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } await this.watchPackages(min, 'gbot'); dir = `work/${gbai}/${botId}.gbui`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } dir = `work/${gbai}/users`; if (!(await GBUtil.exists(dir))) { mkdirp.sync(dir); } // Calls the loadBot context.activity for all packages. await this.invokeLoadBot(min.appPackages, GBServer.globals.sysPackages, min); const receiver = async (req, res) => { let path = /(http[s]?:\/\/)?([^\/\s]+\/)(.*)/gi; const botId = req.url.substr(req.url.lastIndexOf('/') + 1); const min = GBServer.globals.minInstances.filter(p => p.instance.botId == botId)[0]; await this.receiver(req, res, conversationState, min, GBServer.globals.appPackages); }; let url = `/api/messages/${instance.botId}`; GBServer.globals.server.post(url, receiver); if (min['default']) { url = `/api/messages`; GBServer.globals.server.post(url, receiver); } GBServer.globals.server.get(url, (req, res) => { if (req.query['hub.mode'] === 'subscribe') { if (req.query['hub.verify_token'] === process.env.FACEBOOK_VERIFY_TOKEN) { const val = req.query['hub.challenge']; res.send(val); } else { GBLog.error('Failed to verify endpoint.'); res.send('OK'); } } res.end(); }); GBLog.verbose(`GeneralBots(${instance.engineName}) listening on: ${url}.`); // Generates MS Teams manifest. const manifest = `${instance.botId}-Teams.zip`; const packageTeams = urlJoin(`work`, GBUtil.getGBAIPath(instance.botId), manifest); if (!(await GBUtil.exists(packageTeams))) { const data = await this.deployer.getBotManifest(instance); await fs.writeFile(packageTeams, data); } // Serves individual URL for each bot user interface. if (process.env.DISABLE_WEB !== 'true') { const uiUrl = `/${instance.botId}`; GBServer.globals.server.get(uiUrl, async (req, res, next) => { await GBSSR.ssrFilter(req, res, next); }); const uiUrlAlt = `/${instance.activationCode}`; GBServer.globals.server.get(uiUrlAlt, async (req, res, next) => { await GBSSR.ssrFilter(req, res, next); }); GBLog.verbose(`Bot UI ${GBMinService.uiPackage} accessible at: ${uiUrl} and ${uiUrlAlt}.`); } // Clients get redirected here in order to create an OAuth authorize url and redirect them to AAD. // There they will authenticate and give their consent to allow this app access to // some resource they own. this.handleOAuthRequests(GBServer.globals.server, min); // After consent is granted AAD redirects here. The ADAL library // is invoked via the AuthenticationContext and retrieves an // access token that can be used to access the user owned resource. this.handleOAuthTokenRequests(GBServer.globals.server, min, instance); // Provides checking of instance health. this.createCheckHealthAddress(GBServer.globals.server, min, min.instance); // Setups official handler for WhatsApp. GBServer.globals.server .all(`/${min.instance.botId}/whatsapp`, async (req, res) => { if (req.query['hub.mode'] === 'subscribe') { const val = req.query['hub.verify_token']; const challenge = min.core.getParam(min.instance, `Meta Challenge`, null); if (challenge && val === challenge) { res.send(req.query['hub.challenge']); res.status(200); GBLogEx.info(min, `Meta callback OK. ${JSON.stringify(req.query)}`); } else { res.status(401); } res.end(); return; } let whatsAppDirectLine = min.whatsAppDirectLine; // Not meta, multiples bots on root bot. if (!req.body.object) { const to = req.body.To.replace(/whatsapp\:\+/gi, ''); whatsAppDirectLine = WhatsappDirectLine.botsByNumber[to]; } if (whatsAppDirectLine) { await whatsAppDirectLine.WhatsAppCallback(req, res, whatsAppDirectLine.botId); } }) .bind(min); GBDeployer.mountGBKBAssets(`${botId}.gbkb`, botId, `${botId}.gbkb`); // Loads API. await this.ensureAPI(); return min; } public static getProviderName(req: any, res: any) { if (!res) { return 'GeneralBots'; } if (req.body.entry) { return 'meta'; } if (req.body?.AccountSid) { return 'official'; } return req.body.phone_id ? 'maytapi' : 'chatapi'; } /** * Creates a listener that can be used by external monitors to check * bot instance health. */ private createCheckHealthAddress(server: any, min: GBMinInstance, instance: IGBInstance) { server.get(`/${min.instance.botId}/check`, async (req, res) => { try { // Performs the checking of WhatsApp API if enabled for this instance. if (min.whatsAppDirectLine != undefined && instance.whatsappServiceKey !== null) { if (!(await min.whatsAppDirectLine.check(min))) { const error = `WhatsApp API lost connection for: ${min.botId}.`; GBLog.error(error); res.status(500).send(error); return; } } // GB is OK, so 200. res.status(200).send(`General Bot ${min.botId} is healthly.`); } catch (error) { // GB is not OK, 500 and detail the information on response content. GBLog.error(error); res.status(500).send(error.toString()); } }); } /** * Handle OAuth2 web service calls for token requests * on https:////token URL. */ private handleOAuthTokenRequests(server: any, min: GBMinInstance, instance: IGBInstance) { server.get(`/${min.instance.botId}/token`, async (req, res) => { let tokenName = req.query['value']; if (!tokenName) { tokenName = ''; } // Checks request state by reading AntiCSRFAttackState from GB Admin infrastructure. const state = await min.adminService.getValue(instance.instanceId, `${tokenName}AntiCSRFAttackState`); if (req.query.state !== state) { const msg = 'WARNING: state field was not provided as anti-CSRF token'; GBLog.error(msg); throw new Error(msg); } const clientId = min.core.getParam(min.instance, `${tokenName} Client ID`, null); const clientSecret = min.core.getParam(min.instance, `${tokenName} Client Secret`, null); const host = min.core.getParam(min.instance, `${tokenName} Host`, null); const tenant = min.core.getParam(min.instance, `${tokenName} Tenant`, null); if (tokenName) { const code = req?.query?.code; let url = urlJoin(host, tenant, 'oauth/token'); let buff = new Buffer(`${clientId}:${clientSecret}`); const base64 = buff.toString('base64'); const options = { method: 'POST', headers: { Accept: '1.0', Authorization: `Basic ${base64}`, 'Content-Type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ grant_type: 'authorization_code', code: code }) }; const result = await fetch(url, options); if (result.status != 200) { throw new Error(`handleOAuthTokenRequests error: ${result.status}: ${result.statusText}.`); } const text = await result.text(); const token = JSON.parse(text); // Saves token to the database. await this.adminService.setValue( instance.instanceId, `${tokenName}accessToken`, token['accessToken'] ? token['accessToken'] : token['access_token'] ); await this.adminService.setValue( instance.instanceId, `${tokenName}refreshToken`, token['refreshToken'] ? token['refreshToken'] : token['refresh_token'] ); await this.adminService.setValue( instance.instanceId, `${tokenName}expiresOn`, token['expiresOn'] ? token['expiresOn'].toString() : new Date(Date.now() + token['expires_in'] * 1000).toString() ); await this.adminService.setValue(instance.instanceId, `${tokenName}AntiCSRFAttackState`, null); } else { const authenticationContext = new AuthenticationContext.AuthenticationContext( urlJoin( tokenName ? host : min.instance.authenticatorAuthorityHostUrl, tokenName ? tenant : min.instance.authenticatorTenant ) ); const resource = 'https://graph.microsoft.com'; // Calls MSFT to get token. authenticationContext.acquireTokenWithAuthorizationCode( req.query.code, urlJoin(process.env.BOT_URL, min.instance.botId, '/token'), resource, tokenName ? clientId : instance.marketplaceId, tokenName ? clientSecret : instance.marketplacePassword, async (err, token) => { if (err) { const msg = `handleOAuthTokenRequests: Error acquiring token: ${err}`; GBLog.error(msg); res.send(msg); } else { // Saves token to the database. await this.adminService.setValue(instance.instanceId, `${tokenName}accessToken`, token['accessToken']); await this.adminService.setValue(instance.instanceId, `${tokenName}refreshToken`, token['refreshToken']); await this.adminService.setValue( instance.instanceId, `${tokenName}expiresOn`, token['expiresOn'].toString() ); await this.adminService.setValue(instance.instanceId, `${tokenName}AntiCSRFAttackState`, null); } } ); } // Inform the home for default .gbui after finishing token retrival. res.redirect(process.env.BOT_URL); }); } /** * Handle OAuth2 web service calls for authorization requests * on https:////auth URL. */ private handleOAuthRequests(server: any, min: GBMinInstance) { server.get(`/${min.instance.botId}/auth`, (req, res) => { let authorizationUrl = urlJoin( min.instance.authenticatorAuthorityHostUrl, min.instance.authenticatorTenant, '/oauth2/authorize' ); authorizationUrl = `${authorizationUrl}?response_type=code&client_id=${ min.instance.marketplaceId }&redirect_uri=${urlJoin(process.env.BOT_URL, min.instance.botId, 'token')}`; GBLogEx.info(min, `HandleOAuthRequests: ${authorizationUrl}.`); res.redirect(authorizationUrl); }); } /** * Returns the instance object to clients requesting bot info. */ private async handleGetInstanceForClient(req: any, res: any) { // Translates the requested botId. let botId = req.params.botId; if (botId === '[default]' || botId === undefined) { botId = GBConfigService.get('BOT_ID'); } // Loads by the botId itself or by the activationCode field. let instance = await this.core.loadInstanceByBotId(botId); if (instance === null) { instance = await this.core.loadInstanceByActivationCode(botId); } GBLogEx.info(instance.instanceId, `Client requested instance for: ${botId}.`); if (instance !== null) { // Gets the webchat token, speech token and theme. const speechToken = instance.speechKey != undefined ? await this.getSTSToken(instance) : null; let theme = instance.theme; // Sends all information to the .gbui web client. if (!theme) { theme = `default.gbtheme`; } let logo = this.core.getParam(instance, 'Logo', null); logo = logo ? urlJoin(instance.botId, 'cache', logo) : 'images/logo-gb.png'; let config = { instanceId: instance.instanceId, botId: botId, theme: theme, speechToken: speechToken, authenticatorTenant: instance.authenticatorTenant, authenticatorClientId: instance.marketplaceId, paramLogoImageUrl: this.core.getParam(instance, 'Logo Image Url', null), paramLogoImageAlt: this.core.getParam(instance, 'Logo Image Alt', null), paramLogoImageWidth: this.core.getParam(instance, 'Logo Image Width', null), paramLogoImageHeight: this.core.getParam(instance, 'Logo Image Height', null), paramLogoImageType: this.core.getParam(instance, 'Logo Image Type', null), logo: logo, color1: this.core.getParam(instance, 'Color1', null), color2: this.core.getParam(instance, 'Color2', null) }; if (!GBConfigService.get('STORAGE_NAME')) { config['domain'] = `http://localhost:${GBConfigService.get('PORT')}/directline/${botId}`; } else { const webchatTokenContainer = await this.getWebchatToken(instance); (config['conversationId'] = webchatTokenContainer.conversationId), (config['webchatToken'] = webchatTokenContainer.token); } res.send(JSON.stringify(config)); } else { const error = `Instance not found while retrieving from .gbui web client: ${botId}.`; res.sendStatus(error); GBLog.error(error); } } /** * Gets Webchat token from Bot Service. */ private async getWebchatToken(instance: any) { const url = 'https://directline.botframework.com/v3/directline/tokens/generate'; const options = { method: 'POST', headers: { Authorization: `Bearer ${instance.webchatKey}` } }; try { const res = await fetch(url, options); return await res.json(); } catch (error) { const msg = `[botId:${instance.botId}] Error calling Direct Line to generate a token for Web control: ${error}.`; return Promise.reject(new Error(msg)); } } /** * Gets a Speech to Text / Text to Speech token from the provider. */ private async getSTSToken(instance: any) { const options = { method: 'POST', headers: { 'Ocp-Apim-Subscription-Key': instance.speechKey } }; const url = urlJoin(instance.speechEndpoint, '/sts/v1.0/issueToken'); try { const res = await fetch(url, options); return res.text(); } catch (error) { const msg = `Error calling Speech to Text client. Error is: ${error}.`; return Promise.reject(new Error(msg)); } } /** * Builds the BOT Framework & GB infrastructures. */ private async buildBotAdapter(instance: any, sysPackages: IGBPackage[], appPackages: IGBPackage[]) { // MSFT stuff. let config = { appId: instance.marketplaceId ? instance.marketplaceId : GBConfigService.get('MARKETPLACE_ID'), appPassword: instance.marketplacePassword ? instance.marketplacePassword : GBConfigService.get('MARKETPLACE_SECRET') }; if (!GBConfigService.get('STORAGE_NAME')) { startRouter(GBServer.globals.server, instance.botId); config['clientOptions'] = { baseUri: `http://localhost:${GBConfigService.get('PORT')}` }; } const adapter = new BotFrameworkAdapter(config); const storage = new MemoryStorage(); const conversationState = new ConversationState(storage); const userState = new UserState(storage); adapter.use(new AutoSaveStateMiddleware(conversationState, userState)); MicrosoftAppCredentials.trustServiceUrl( 'https://directline.botframework.com', new Date(new Date().setFullYear(new Date().getFullYear() + 10)) ); // The minimal bot is built here. const min = new GBMinInstance(); // Setups default BOT Framework dialogs. min.userProfile = conversationState.createProperty('userProfile'); const dialogState = conversationState.createProperty('dialogState'); min.dialogs = new DialogSet(dialogState); min.dialogs.add(new TextPrompt('textPrompt')); min.dialogs.add(new AttachmentPrompt('attachmentPrompt')); min.dialogs.add(new ConfirmPrompt('confirmPrompt')); if (process.env.ENABLE_AUTH) { min.dialogs.add( new OAuthPrompt('oAuthPrompt', { connectionName: 'OAuth2', text: 'Please sign in to General Bots.', title: 'Sign in', timeout: 300000 }) ); } min.botId = instance.botId; min.bot = adapter; min.userState = userState; min.core = this.core; min.conversationalService = this.conversationalService; min.adminService = this.adminService; min.deployService = this.deployer; min.kbService = new KBService(this.core.sequelize); min.instance = instance; min.cbMap = {}; min.scriptMap = {}; min.sandBoxMap = {}; min['scheduleMap'] = {}; min['conversationWelcomed'] = {}; if (await min.core.getParam(min.instance, 'Answer Mode', null)) { const gbkbPath = GBUtil.getGBAIPath(min.botId, 'gbkb'); min['vectorStorePath'] = path.join('work', gbkbPath, 'docs-vectorized'); min['vectorStore'] = await this.deployer.loadOrCreateEmptyVectorStore(min); } min['apiConversations'] = {}; min.packages = sysPackages; // NLP Manager. const manager = new NlpManager({ languages: ['pt'], forceNER: true }); min['nerEngine'] = manager; if (!GBServer.globals.minBoot.botId) { GBServer.globals.minBoot = min; GBServer.globals.minBoot.instance.marketplaceId = GBConfigService.get('MARKETPLACE_ID'); GBServer.globals.minBoot.instance.marketplacePassword = GBConfigService.get('MARKETPLACE_SECRET'); } if (min.instance.facebookWorkplaceVerifyToken) { min['fbAdapter'] = new FacebookAdapter({ verify_token: min.instance.facebookWorkplaceVerifyToken, app_secret: min.instance.facebookWorkplaceAppSecret, access_token: min.instance.facebookWorkplaceAccessToken }); } min.appPackages = await this.core['getApplicationsByInstanceId'](appPackages, min.instance.instanceId); // Creates a hub of services available in .gbapps. await CollectionUtil.asyncForEach(min.appPackages, async (e: IGBPackage) => { let services: ConcatArray; if ((services = await e.onExchangeData(min, 'getServices', null))) { min.gbappServices = { ...min.gbappServices, ...services }; } }); if (min.instance.googlePrivateKey) { min['googleDirectLine'] = new GoogleChatDirectLine( min, min.botId, min.instance.googleBotKey, min.instance.googleChatSubscriptionName, min.instance.googleChatApiKey, min.instance.googleClientEmail, min.instance.googlePrivateKey.replace(/\\n/gm, '\n'), min.instance.googleProjectId ); await min['googleDirectLine'].setup(true); } const group = min.core.getParam(min.instance, 'WhatsApp Group ID', null); WhatsappDirectLine.botGroups[min.botId] = group; const minBoot = GBServer.globals.minBoot as any; // If there is WhatsApp configuration specified, initialize // infrastructure objects. if (min.instance.whatsappServiceKey) { min.whatsAppDirectLine = new WhatsappDirectLine( min, min.botId, min.instance.webchatKey, min.instance.whatsappServiceKey, min.instance.whatsappServiceNumber, min.instance.whatsappServiceUrl, group ); await min.whatsAppDirectLine.setup(true); } else { if (min !== minBoot && minBoot.instance.whatsappServiceKey && min.instance.webchatKey) { min.whatsAppDirectLine = new WhatsappDirectLine( min, min.botId, min.instance.webchatKey, minBoot.instance.whatsappServiceKey, minBoot.instance.whatsappServiceNumber, minBoot.instance.whatsappServiceUrl, group ); await min.whatsAppDirectLine.setup(false); } } // Builds bot numbers map in WhatsAppDirectLine globals. let botNumber = min.core.getParam(min.instance, 'Bot Number', null); if (botNumber) { WhatsappDirectLine.botsByNumber[botNumber] = min.whatsAppDirectLine; } min['default'] = min === minBoot; return { min, adapter, conversationState }; } /** * Performs calling of loadBot event in all .gbapps. */ private async invokeLoadBot(appPackages: IGBPackage[], sysPackages: IGBPackage[], min: GBMinInstance) { // Calls loadBot event in all .gbapp packages. await CollectionUtil.asyncForEach(sysPackages, async p => { p.sysPackages = sysPackages; if (p.getDialogs !== undefined) { const dialogs = await p.getDialogs(min); if (dialogs !== undefined) { dialogs.forEach(dialog => { min.dialogs.add(new WaterfallDialog(dialog.id, dialog.waterfall)); }); } } await p.loadBot(min); }); // Adds all dialogs from .gbapps into global dialo list for this minimal instance. await CollectionUtil.asyncForEach(appPackages, async p => { p.sysPackages = sysPackages; await p.loadBot(min); if (p.getDialogs !== undefined) { const dialogs = await p.getDialogs(min); if (dialogs !== undefined) { dialogs.forEach(dialog => { min.dialogs.add(new WaterfallDialog(dialog.id, dialog.waterfall)); }); } } }); } // https://github.com/GeneralBots/BotServer/issues/313 public static userMobile(step) { let mobile = WhatsappDirectLine.mobiles[step.context.activity.conversation.id]; if (!mobile && step) { return step.context.activity.from.id; } return mobile; } /** * BOT Framework web service hook method. */ private async receiver( req: any, res: any, conversationState: ConversationState, min: GBMinInstance, appPackages: any[] ) { // Uses standard or Facebook Adapter. let adapter = min.bot; if (req.body.object) { req['rawBody'] = JSON.stringify(req.body); adapter = min['fbAdapter']; } // Unifies channel detection. Unmarshalls group information. req.body.channelId = req.body.from.channelIdEx === 'whatsapp' ? 'omnichannel' : req.body.channelId; req.body.group = req.body.from.group; // Default activity processing and handler. const handler = async context => { // Handle activity text issues. if (!context.activity.text) { context.activity.text = ''; } context.activity.text = context.activity.text.replace(/\@General Bots Online /gi, ''); // Get loaded user state const step = await min.dialogs.createContext(context); step.context.activity.locale = 'pt-BR'; const member = context.activity.from; const sec = new SecService(); const user = await sec.ensureUser(min, member.id, member.name, '', 'web', member.name, null); const userId = user.userId; const params = user.params ? JSON.parse(user.params) : {}; try { const conversationReference = JSON.stringify(TurnContext.getConversationReference(context.activity)); // First time processing. if (!params.loaded) { if (step.context.activity.channelId !== 'msteams') { await min.conversationalService.sendEvent(min, step, 'loadInstance', {}); } // Default params. await sec.setParam(userId, 'loaded', true); await sec.setParam(userId, 'subjects', '[]'); await sec.setParam(userId, 'cb', null); await sec.setParam(userId, 'welcomed', 'false'); await sec.setParam(userId, 'maxLines', 100); await sec.setParam(userId, 'translatorOn', true); await sec.setParam(userId, 'wholeWord', true); await sec.setParam(userId, 'theme', 'white'); await sec.setParam(userId, 'maxColumns', 40); // This same event is dispatched either to all participants // including the bot, that is filtered bellow. if (context.activity.from.id !== min.botId) { // Creates a new row in user table if it does not exists. if (process.env.PRIVACY_STORE_MESSAGES === 'true') { // Stores conversation associated to the user to group each message. const analytics = new AnalyticsService(); await analytics.createConversation(user); } } await sec.updateConversationReferenceById(userId, conversationReference); if (step.context.activity.channelId !== 'msteams') { const service = new KBService(min.core.sequelize); const data = await service.getFaqBySubjectArray(min.instance.instanceId, 'faq', undefined); await min.conversationalService.sendEvent(min, step, 'play', { playerType: 'bullet', data: data.slice(0, 10) }); } } let pid = step.context.activity['pid']; if (!pid) { pid = GBVMService.createProcessInfo(user, min, step.context.activity.channelId, null, step); } step.context.activity['pid'] = pid; // Required for MSTEAMS handling of persisted conversations. if (step.context.activity.channelId === 'msteams') { if (step.context.activity.attachments && step.context.activity.attachments.length > 1) { const file = context.activity.attachments[0]; const credentials = new MicrosoftAppCredentials( min.instance.marketplaceId, min.instance.marketplacePassword ); const botToken = await credentials.getToken(); const headers = { Authorization: `Bearer ${botToken}` }; const t = new SystemKeywords(); const data = await t.getByHttp({ pid: 0, url: file.contentUrl, headers, username: null, ps: null, qs: null }); const packagePath = GBUtil.getGBAIPath(min.botId); const folder = `work/${path}/cache`; const filename = `${GBAdminService.generateUuid()}.png`; await fs.writeFile(urlJoin(folder, filename), data); step.context.activity.text = urlJoin( GBServer.globals.publicAddress, `${min.instance.botId}`, 'cache', filename ); } if (!(await sec.getParam(user, 'welcomed'))) { const startDialog = min.core.getParam(min.instance, 'Start Dialog', null); if (startDialog) { await sec.setParam(userId, 'welcomed', 'true'); GBLogEx.info( min, `Auto start (teams) dialog is now being called: ${startDialog} for ${min.instance.botId}...` ); await GBVMService.callVM(startDialog.toLowerCase(), min, step, pid); } } } // Required for F0 handling of persisted conversations. GBLogEx.info( min, `Input> ${context.activity.text} (type: ${context.activity.type}, name: ${context.activity.name}, channelId: ${context.activity.channelId})` ); // Answer to specific BOT Framework event conversationUpdate to auto start dialogs. // Skips if the bot is talking. const startDialog = min.core.getParam(min.instance, 'Start Dialog', null); if (context.activity.type === 'installationUpdate') { GBLogEx.info(min, `Bot installed on Teams.`); } else if (context.activity.type === 'conversationUpdate' && context.activity.membersAdded.length > 0) { // Check if a bot or a human participant is being added to the conversation. const member = context.activity.membersAdded[0]; if (context.activity.membersAdded[0].id === context.activity.recipient.id) { GBLogEx.info(min, `Bot added to conversation, starting chat...`); // Calls onNewSession event on each .gbapp package. await CollectionUtil.asyncForEach(appPackages, async e => { await e.onNewSession(min, step); }); // Auto starts dialogs if any is specified. if (!startDialog && !(await sec.getParam(user, 'welcomed'))) { // Otherwise, calls / (root) to default welcome users. await step.beginDialog('/'); } else { if ( !GBMinService.userMobile(step) && !min['conversationWelcomed'][step.context.activity.conversation.id] ) { min['conversationWelcomed'][step.context.activity.conversation.id] = true; GBLogEx.info( min, `Auto start (web 1) dialog is now being called: ${startDialog} for ${min.instance.instanceId}...` ); await GBVMService.callVM(startDialog.toLowerCase(), min, step, pid); } } } else { GBLogEx.info(min, `Person added to conversation: ${member.name}`); return; } } else if (context.activity.type === 'message') { // Processes messages activities. await this.processMessageActivity(context, min, step, pid); } else if (context.activity.type === 'event') { // Processes events activities. await this.processEventActivity(min, user, context, step); } } catch (error) { const msg = `ERROR: ${error.message} ${error.stack} ${error.error ? error.error.body : ''} ${ error.error ? (error.error.stack ? error.error.stack : '') : '' }`; GBLog.error(msg); await min.conversationalService.sendText( min, step, Messages[step.context.activity.locale].very_sorry_about_error ); await step.beginDialog('/ask', { isReturning: true }); } }; try { if (!GBConfigService.get('STORAGE_NAME')) { const context = adapter['createContext'](req); context['_activity'] = context.activity.body; await handler(context); // Return status res.status(200); res.end(); } else { await adapter['processActivity'](req, res, handler); } } catch (error) { if (error.code === 401) { GBLog.error('Calling processActivity due to Signing Key could not be retrieved error.'); await adapter['processActivity'](req, res, handler); } else { throw error; } } } /** * Called to handle all event sent by .gbui clients. */ private async processEventActivity(min, user, context, step: GBDialogStep) { const pid = step.context.activity['pid']; if (context.activity.name === 'whoAmI') { await step.beginDialog('/whoAmI'); } else if (context.activity.name === 'showSubjects') { await step.beginDialog('/menu', undefined); } else if (context.activity.name === 'giveFeedback') { await step.beginDialog('/feedback', { fromMenu: true }); } else if (context.activity.name === 'showFAQ') { await step.beginDialog('/faq'); } else if (context.activity.name === 'answerEvent') { await step.beginDialog('/answerEvent', { questionId: context.activity.data, fromFaq: true }); } else if (context.activity.name === 'quality') { await step.beginDialog('/quality', { score: context.activity.data }); } else if (context.activity.name === 'startGB') { const startDialog = min.core.getParam(min.instance, 'Start Dialog', null); if (startDialog && !min['conversationWelcomed'][step.context.activity.conversation.id]) { user.welcomed = true; GBLogEx.info( min, `Auto start (web 2) dialog is now being called: ${startDialog} for ${min.instance.instanceId}...` ); await GBVMService.callVM(startDialog.toLowerCase(), min, step, pid); } } else if (context.activity.name === 'updateToken') { const token = context.activity.data; await step.beginDialog('/adminUpdateToken', { token: token }); } else { await step.continueDialog(); } } /** * Private handler which receives the Attachment and persists to disk. * during a HEAR attachment AS FILE upload. */ // ... private static async downloadAttachmentAndWrite(attachment) { const url = attachment.contentUrl; const localFolder = 'work'; const packagePath = GBUtil.getGBAIPath(this['min'].botId); const localFileName = path.join(localFolder, packagePath, 'uploads', attachment.name); let buffer; if (url.startsWith('data:')) { const base64Data = url.split(';base64,')[1]; buffer = Buffer.from(base64Data, 'base64'); } else { const options = { method: 'GET', encoding: 'binary' }; const res = await fetch(url, options); buffer = arrayBufferToBuffer(await res.arrayBuffer()); } await fs.writeFile(localFileName, buffer); return { fileName: attachment.name, localPath: localFileName }; } /** * * Checks for global exit kewywords cancelling any active dialogs. * * */ public static isGlobalQuitUtterance(locale, utterance) { return utterance.match(Messages.global_quit); } private async handleUploads(min, step, user, params, autoSave) { // Prepare Promises to download each attachment and then execute each Promise. if ( step.context.activity.attachments && step.context.activity.attachments[0] && step.context.activity.attachments[0].contentType != 'text/html' ) { const promises = step.context.activity.attachments.map( GBMinService.downloadAttachmentAndWrite.bind({ min, user, params }) ); const successfulSaves = await Promise.all(promises); async function replyForReceivedAttachments(attachmentData) { if (attachmentData) { // In case of not having HEAR activated before, it is // a upload with no Dialog, so run Auto Save to .gbdrive. const t = new SystemKeywords(); GBLogEx.info(min, `BASIC (${min.botId}): Upload done for ${attachmentData.fileName}.`); const handle = WebAutomationServices.cyrb53({ pid: 0, str: min.botId + attachmentData.fileName }); let data = await fs.readFile(attachmentData.localPath); const gbfile = { filename: attachmentData.localPath, data: data, name: path.basename(attachmentData.fileName) }; GBServer.globals.files[handle] = gbfile; if (!min.cbMap[user.userId] && autoSave) { const result = await t['internalAutoSave']({ min: min, handle: handle }); await min.conversationalService.sendText( min, step, `Seu arquivo ${gbfile.name} foi salvo no .gbdrive (${result.category}).` ); return; } else { return gbfile; } } else { await this.sendActivity('Error uploading file. Please,start again.'); } } const replyPromises = successfulSaves.map(replyForReceivedAttachments.bind(step.context)); await Promise.all(replyPromises); if (successfulSaves.length > 0) { class GBFile { data: Buffer; filename: string; } const results = successfulSaves.reduce(async (accum: GBFile[], item) => { const result: GBFile = { data: await fs.readFile(successfulSaves[0]['localPath']), filename: successfulSaves[0]['fileName'] }; accum.push(result); return accum; }, []) as GBFile[]; if (min.cbMap[user.userId] && min.cbMap[user.userId].promise == '!GBHEAR') { if (results.length > 1) { throw new Error('It is only possible to upload one file per message, right now.'); } min.cbMap[user.userId].promise = results[0]; } else { return; } } } } /** * Called to handle all text messages sent and received by the bot. */ private async processMessageActivity(context, min: GBMinInstance, step: GBDialogStep, pid) { const sec = new SecService(); if (!context.activity.text) { context.activity.text = ''; } // Removes Bot Id from MS Teams. context.activity.text = context.activity.text.replace(/\.*\<\/at\>\s/gi, ''); let data = { query: context.activity.text }; await CollectionUtil.asyncForEach(min.appPackages, async (e: IGBPackage) => { await e.onExchangeData(min, 'handleRawInput', data); }); context.activity.text = data.query; // Additional clean up. context.activity.text = context.activity.text.trim(); const member = context.activity.from; let memberId = null, email = null; // Processes e-mail from id in case of Teams messages. if (member.id.startsWith('29:')) { const token = await (min.adminService as any)['acquireElevatedToken'](min.instance.instanceId, false); const url = `https://graph.microsoft.com/v1.0/users/${context.activity.from.aadObjectId}`; const options = { method: 'GET', headers: { Authorization: `Bearer ${token}` } }; try { const res = await fetch(url, options); const member = JSON.parse(await res.text()); memberId = member.mail; email = member.mail; } catch (error) { throw `[botId:${min.instance.botId}] Error calling Teams to get user info: ${error}.`; } } else { memberId = member.id; } let user = await sec.ensureUser(min, memberId, member.name, '', 'web', member.name, email); const userId = user.userId; const params = user.params ? JSON.parse(user.params) : {}; let message: GuaribasConversationMessage; if (process.env.PRIVACY_STORE_MESSAGES === 'true') { // Adds message to the analytics layer. const analytics = new AnalyticsService(); if (user) { let conversation; if (!user.conversationId) { conversation = await analytics.createConversation(user); user.conversationId = conversation.Id; } message = await analytics.createMessage( min.instance.instanceId, user.conversationId, userId, context.activity.text ); } } const conversationReference = JSON.stringify(TurnContext.getConversationReference(context.activity)); await sec.updateConversationReferenceById(userId, conversationReference); if (GBMinService.userMobile(step)) { const startDialog = user.hearOnDialog ? user.hearOnDialog : min.core.getParam(min.instance, 'Start Dialog', null); if ( startDialog && startDialog !== '' && !min['conversationWelcomed'][step.context.activity.conversation.id] && !min['apiConversations'][pid] && !step.context.activity['group'] ) { await sec.setParam(userId, 'welcomed', 'true'); min['conversationWelcomed'][step.context.activity.conversation.id] = true; GBLogEx.info( min, `Auto start (4) dialog is now being called: ${startDialog} for ${min.instance.instanceId}...` ); await GBVMService.callVM(startDialog.toLowerCase(), min, step, pid); return; } } const notes = min.core.getParam(min.instance, 'Notes', null); await this.handleUploads(min, step, user, params, notes != null); // Files in .gbdialog can be called directly by typing its name normalized into JS . const isVMCall = Object.keys(min.scriptMap).find(key => min.scriptMap[key] === context.activity.text) !== undefined; // TODO: Externalize intents for LLM. if (/create dialog|creative dialog|create a dialog|criar diálogo|criar diálogo/gi.test(context.activity.text)) { await step.beginDialog('/dialog'); } else if (isVMCall) { await GBVMService.callVM(context.activity.text, min, step, pid); } else if (context.activity.text.charAt(0) === '/') { const text = context.activity.text; const parts = text.split(' '); const cmdOrDialogName = parts[0]; parts.splice(0, 1); const args = parts.join(' '); if (cmdOrDialogName === '/start') { // Reset user. await min.conversationalService.sendEvent(min, step, 'loadInstance', {}); } else if (cmdOrDialogName === '/call') { await GBVMService.callVM(args, min, step, pid); } else if (cmdOrDialogName === '/callsch') { await GBVMService.callVM(args, min, null, pid); } else if (cmdOrDialogName === '/calldbg') { await GBVMService.callVM(args, min, step, pid, true); } else { await step.beginDialog(cmdOrDialogName, { args: args }); } } else if (GBMinService.isGlobalQuitUtterance(step.context.activity.locale, context.activity.text)) { await step.cancelAllDialogs(); await min.conversationalService.sendText(min, step, Messages[step.context.activity.locale].canceled); } else if (context.activity.text === 'admin') { await step.beginDialog('/admin'); } else if (context.activity.text.startsWith('{"title"')) { await step.beginDialog('/menu', JSON.parse(context.activity.text)); } else if ( !(await this.deployer.getStoragePackageByName(min.instance.instanceId, `${min.instance.botId}.gbkb`)) && process.env.GBKB_ENABLE_AUTO_PUBLISH === 'true' ) { await min.conversationalService.sendText( min, step, `Oi, ainda não possuo pacotes de conhecimento publicados. Por favor, aguarde alguns segundos enquanto eu auto-publico alguns pacotes.` ); await step.beginDialog('/publish', { confirm: true, firstTime: true }); } else { // Removes unwanted chars in input text. step.context.activity['originalText'] = context.activity.text; const text = await GBConversationalService.handleText(min, user, step, context.activity.text); step.context.activity['originalText']; step.context.activity['text'] = text; if (notes && text && text !== '') { const sys = new SystemKeywords(); await sys.note({ pid, text }); await step.context.sendActivity('OK.'); return; } // Checks for bad words on input text. const hasBadWord = wash.check(step.context.activity.locale, text); if (hasBadWord) { return await step.beginDialog('/pleaseNoBadWords'); } if (user.agentMode === 'self') { const manualUser = await sec.getUserFromAgentSystemId(user.userSystemId); GBLogEx.info(min, `HUMAN AGENT (${user.userId}) TO USER ${manualUser.userSystemId}: ${text}`); const cmd = 'SEND FILE '; if (text.startsWith(cmd)) { const filename = text.substr(cmd.length); const message = await min.kbService.getAnswerTextByMediaName(min.instance.instanceId, filename); if (message === null) { GBLog.error( `File ${filename} not found in any .gbkb published. Check the name or publish again the associated .gbkb.` ); } else { await min.conversationalService.sendMarkdownToMobile(min, null, manualUser.userSystemId, message); } } else { await min.whatsAppDirectLine.sendToDeviceEx( manualUser.userSystemId, `${manualUser.agentSystemId}: ${text}`, step.context.activity.locale, step.context.activity.conversation.id ); } } else { if (min.cbMap[userId] && min.cbMap[userId].promise === '!GBHEAR') { min.cbMap[userId].promise = step.context.activity['originalText']; } // If there is a dialog in course, continue to the next step. else if (step.activeDialog !== undefined) { try { await step.continueDialog(); } catch (error) { const msg = `ERROR: ${error.message} ${error.stack} ${error.error ? error.error.body : ''} ${ error.error ? (error.error.stack ? error.error.stack : '') : '' }`; GBLog.error(msg); await min.conversationalService.sendText( min, step, Messages[step.context.activity.locale].very_sorry_about_error ); await step.beginDialog('/ask', { isReturning: true }); } } else { const startDialog = user.hearOnDialog ? user.hearOnDialog : min.core.getParam(min.instance, 'Start Dialog', null); if (text !== startDialog) { let nextDialog = null; let data = { query: text, step: step, notTranslatedQuery: context.activity.text, message: message ? message['dataValues'] : null, user: user ? user.dataValues : null }; await CollectionUtil.asyncForEach(min.appPackages, async (e: IGBPackage) => { if (!nextDialog) { nextDialog = await e.onExchangeData(min, 'handleAnswer', data); } }); data.step = null; GBLogEx.info(min, `/answer being called from processMessageActivity (nextDialog=${nextDialog}).`); await step.beginDialog(nextDialog ? nextDialog : '/answer', { data: data, query: text, user: user ? user.dataValues : null, message: message }); } } } } } public async ensureAPI() { const mins = GBServer.globals.minInstances; function getRemoteId(ctx: Koa.Context) { return '1'; // Each bot has its own API. } const close = async () => { return new Promise(resolve => { if (GBServer.globals.server.apiServer) { GBServer.globals.server.apiServer.close(cb => { resolve(true); }); } else { resolve(true); GBLogEx.info(0, 'Loading General Bots API...'); } }); }; await close(); let proxies = {}; await CollectionUtil.asyncForEach(mins, async min => { let dialogs = {}; await CollectionUtil.asyncForEach(Object.values(min.scriptMap), async script => { dialogs[script] = async data => { let sec = new SecService(); const user = await sec.ensureUser( min, data.userSystemId, data.userSystemId, '', 'api', data.userSystemId, null ); let pid = data?.pid; if (script === 'start') { pid = GBVMService.createProcessInfo(user, min, 'api', null); const client = await GBUtil.getDirectLineClient(min); const response = await client.apis.Conversations.Conversations_StartConversation(); min['apiConversations'][pid] = { conversation: response.obj, client: client }; min['conversationWelcomed'][response.obj.id] = true; } let ret = await GBVMService.callVM(script, min, null, pid, false, data); if (script === 'start') { ret = pid; } return ret; }; }); const proxy = { dk: new DialogKeywords(), wa: new WebAutomationServices(), sys: new SystemKeywords(), dbg: new DebuggerService(), img: new ImageProcessingServices(), dialogs: dialogs }; proxies[min.botId] = proxy; }); const opts = { pingSendTimeout: null, keepAliveTimeout: null, listeners: { unsubscribed(subscriptions: number): void {}, subscribed(subscriptions: number): void {}, disconnected(remoteId: string, connections: number): void {}, connected(remoteId: string, connections: number): void {}, messageIn(...params): void { params.shift(); }, messageOut(...params): void { params.shift(); } } }; GBServer.globals.server.apiServer = createKoaHttpServer(GBVMService.API_PORT, getRemoteId, { prefix: `api/v3` }); createRpcServer(proxies, GBServer.globals.server.apiServer, opts); } // Map to track recent changes with timestamps private recentChanges: Map = new Map(); private async watchPackages(min: GBMinInstance, packageType) { if (!GBConfigService.get('STORAGE_NAME')) { const packagePath = GBUtil.getGBAIPath(min.botId, packageType); const dirPath = path.join(GBConfigService.get('STORAGE_LIBRARY'), packagePath); const watcher = chokidar.watch(dirPath, { persistent: true, ignoreInitial: true, // Ignore initial add events depth: 99, // Watch subdirectories awaitWriteFinish: { stabilityThreshold: 500, // Wait for 500ms to ensure file is written completely } }); const WRITE_INTERVAL = 5000; // 5 seconds interval // Function to handle file changes and prevent multiple calls within the 5-second window const handleFileChange = async (filePath) => { const now = Date.now(); // Add or update the file in the recent changes list this.recentChanges.set(filePath, now); // Clean up entries older than 5 seconds for (const [key, timestamp] of this.recentChanges.entries()) { if (now - timestamp > WRITE_INTERVAL) { this.recentChanges.delete(key); } } // If we have recent changes, deploy the package only once if (this.recentChanges.size > 0) { try { await this.deployer.deployPackage2(min, null, dirPath); } catch (error) { GBLogEx.error(min, `Error deploying package: ${GBUtil.toYAML(error)}`); } // Delay further processing to prevent multiple deployments within 5 seconds await new Promise(resolve => setTimeout(resolve, WRITE_INTERVAL)); // After the delay, clear only entries that were processed this.recentChanges.clear(); } }; // Watch for file changes watcher.on('change', (filePath) => { handleFileChange(filePath).catch(error => console.error('Error processing file change:', error)); }); } } }