@smythos/sre 1.6.13 → 1.7.1

package/src/Components/Triggers/Trigger.class.ts

@@ -0,0 +1,101 @@
+import { Agent } from '@sre/AgentManager/Agent.class';
+import { Component } from '../Component.class';
+import { LogHelper } from '@sre/helpers/Log.helper';
+import express from 'express';
+import { AgentRequest } from '@sre/AgentManager/AgentRequest.class';
+import { IAgent } from '@sre/types/Agent.types';
+
+export class Trigger extends Component {
+    protected logger: LogHelper;
+
+    async process(input, settings, agent: Agent) {
+        await super.process(input, settings, agent);
+        this.logger = this.createComponentLogger(agent, settings);
+        try {
+            const agentRequest: AgentRequest = agent.agentRequest;
+            const processedRequest = await this.requestHandler(input, settings, agent);
+            if (processedRequest) {
+                agent.kill('TRIGGER_REQ_HANDLED'); //should not be handled by the agent
+                return processedRequest;
+            }
+
+            //a trigger should always return an array of payloads
+            //if it's a single object, it should be wrapped in an array
+            let inputArray = await this.collectPayload(input, settings, agent);
+            if (inputArray.length < 2) {
+                return { Payload: inputArray?.[0], _error: null, _in_progress: false, _debug: this.logger.output };
+            }
+            return await this.processIteration(inputArray, settings, agent);
+        } catch (error) {
+            this.logger.error(error);
+            return { Payload: {}, Result: [], _error: error, _in_progress: false, _debug: this.logger.output };
+        }
+    }
+    protected async collectPayload(input, settings, agent: Agent): Promise<any[]> {
+        return [];
+    }
+    public async requestHandler(input, settings, agent: Agent): Promise<any> {}
+
+    protected async processIteration(inputArray, settings, agent) {
+        let Payload = {};
+        let Result;
+        let _temp_result;
+        let _error = null;
+        let _in_progress = true;
+        const logger = this.logger;
+
+        const runtimeData = agent.agentRuntime.getRuntimeData(settings.id);
+        const _LoopData = runtimeData._LoopData || { parentId: settings.id, loopIndex: 0, loopLength: inputArray.length };
+
+        logger.debug(`Loop: ${_LoopData.loopIndex} / ${_LoopData.loopLength}`);
+        delete _LoopData.branches; //reset branches (the number of branches is calculated in CallComponent@Agent.class.ts )
+
+        if (_LoopData.result) {
+            _temp_result = _LoopData.result;
+            logger.debug(`  => Trigger Iteration Result : ${JSON.stringify(Payload, null, 2)}`);
+            logger.debug(`---------------------------------------------------`);
+        }
+
+        Payload = inputArray[_LoopData.loopIndex];
+
+        logger.debug(`  => Trigger Iteration Data : ${JSON.stringify(Payload, null, 2)}`);
+
+        _in_progress = Payload !== undefined;
+        if (_in_progress) {
+            _LoopData.loopIndex++;
+        }
+        _LoopData._in_progress = _in_progress;
+
+        agent.agentRuntime.updateRuntimeData(settings.id, { _LoopData: _LoopData });
+
+        if (!_in_progress) {
+            Result = (_temp_result || []).map((item) => cleanupResult(item.result || item));
+        }
+        return { Payload, Result, _temp_result, _error, _in_progress, _debug: logger.output };
+    }
+
+    async postProcess(output, settings, agent: Agent): Promise<any> {
+        output = await super.postProcess(output, settings, agent);
+        return output?.result.Result;
+    }
+
+    /**
+     * This function is used to register a trigger,
+     * It can be called by a visual builder when saving a trigger component.
+     * it performs the necessary actions to register the trigger with the external service or with the internal scheduler.
+     * @param componentId - The id of the component to register
+     * @param componentSettings - The settings of the component to register
+     * @param payload - The payload to register the trigger with
+     * @returns A promise that resolves to the result of the registration
+     */
+    async register(componentId: string, componentSettings: any, payload: { agentData: IAgent; triggerUrl: string }) {}
+}
+
+function cleanupResult(result) {
+    if (typeof result !== 'object') return result;
+    if (result._debug) delete result._debug;
+    if (result._error) delete result._error;
+    if (result._temp_result) delete result._temp_result;
+    if (result._in_progress) delete result._in_progress;
+    return result;
+}

package/src/Components/Triggers/WhatsApp.trigger.ts

@@ -0,0 +1,219 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+import { AgentRequest } from '@sre/AgentManager/AgentRequest.class';
+import express from 'express';
+
+type WhatsAppIncomingMessage = {
+    id?: string;
+    from?: string;
+    profileName?: string;
+    text?: string;
+    type?: string;
+    timestamp?: string;
+    phoneNumberId?: string;
+};
+
+export class WhatsAppTrigger extends Trigger {
+    async collectPayload(input, settings, agent: Agent) {
+        const req = agent.agentRequest;
+        const body = req?.body || {};
+        agent.agentRequest.res.sendStatus(200); //Whatsapp expects immediate response
+
+        const message = extractFirstIncomingMessage(body);
+        if (!message) return [];
+
+        return [
+            {
+                message,
+            },
+        ];
+    }
+
+    async requestHandler(input, settings, agent: Agent) {
+        const req = agent.agentRequest?.req || agent.agentRequest;
+        const res = agent.agentRequest?.res;
+
+        if (!req || !res) return null;
+
+        const method = (req?.method || 'POST').toUpperCase();
+        const query = req?.query || {};
+
+        // Handle Facebook webhook verification (GET request)
+        if (method === 'GET') {
+            // Get config from request (should be attached by the router)
+
+            const verificationResult = handleVerification(query, settings?.data);
+
+            if (verificationResult) {
+                if (verificationResult.valid) {
+                    // Send plain text response with the challenge (exactly as Facebook expects)
+                    res.status(200).type('text/plain').send(verificationResult.challenge);
+                } else {
+                    res.status(403).send('Forbidden');
+                }
+                return true; // Indicate that we handled the response
+            }
+        }
+
+        // For POST requests (actual messages), return null to let normal flow continue
+        return null;
+    }
+
+    async register(componentId: string, componentSettings: any, payload?: { triggerUrl: string }) {
+        const verifyToken = componentSettings?.verifyToken || componentSettings?.verify_token;
+        const clientId = componentSettings?.clientId || componentSettings?.appId;
+        const clientSecret = componentSettings?.clientSecret || componentSettings?.appSecret;
+        const subscriptionFields = ['messages', 'message_template_status_update'];
+
+        const inferredWebhookUrl = payload?.triggerUrl;
+        const webhookUrl = (componentSettings?.webhookUrl || inferredWebhookUrl || '').split('?')[0];
+
+        if (!clientId || !clientSecret) throw new Error('WhatsAppTrigger.register: Missing clientId/clientSecret');
+        if (!verifyToken) throw new Error('WhatsAppTrigger.register: Missing verifyToken');
+        if (!webhookUrl) throw new Error('WhatsAppTrigger.register: Missing webhookUrl');
+
+        const accessToken = await getAppAccessToken(clientId, clientSecret);
+
+        // If a subscription exists, delete it first, then create a new one
+        const existingSubscriptions = await listWebhookSubscriptions(clientId, accessToken);
+        const existing = (existingSubscriptions || []).find((s: any) => s.object === 'whatsapp_business_account' && s.active);
+        if (existing) {
+            await deleteWebhookSubscription(clientId, accessToken);
+        }
+
+        await createWebhookSubscription(clientId, accessToken, {
+            callback_url: webhookUrl,
+            verify_token: verifyToken,
+            fields: subscriptionFields,
+        });
+    }
+
+    async unregister(componentId: string, agent: Agent, payload?: any) {
+        const componentSchema = await agent.components[componentId];
+        const data = componentSchema?.data || {};
+        const clientId = data?.clientId || data?.appId;
+        const clientSecret = data?.clientSecret || data?.appSecret;
+
+        if (!clientId || !clientSecret) throw new Error('WhatsAppTrigger.unregister: Missing clientId/clientSecret');
+
+        const accessToken = await getAppAccessToken(clientId, clientSecret);
+        await deleteWebhookSubscription(clientId, accessToken);
+    }
+}
+
+function handleVerification(query: any, config: any) {
+    if (!(query?.['hub.mode'] === 'subscribe' || query?.['hub.mode'] === 'SUBSCRIBE')) return null;
+
+    const providedToken = query['hub.verify_token'] || query['hub.verifyToken'];
+    const expectedToken = config?.verifyToken || config?.verify_token;
+    const challenge = query['hub.challenge'];
+    const valid = expectedToken ? String(providedToken) === String(expectedToken) : false;
+
+    return {
+        valid,
+        challenge,
+        mode: query['hub.mode'],
+    };
+}
+
+async function getAppAccessToken(clientId: string, clientSecret: string) {
+    const url = 'https://graph.facebook.com/v19.0/oauth/access_token';
+    const body = new URLSearchParams({
+        client_id: clientId,
+        client_secret: clientSecret,
+        grant_type: 'client_credentials',
+    }).toString();
+
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body,
+    });
+    const json = await res.json();
+    if (!res.ok) throw new Error(`getAppAccessToken failed: ${json?.error?.message || res.status}`);
+    return json.access_token as string;
+}
+
+async function listWebhookSubscriptions(clientId: string, accessToken: string) {
+    const url = `https://graph.facebook.com/v19.0/${clientId}/subscriptions`;
+    const res = await fetch(url, {
+        method: 'GET',
+        headers: { Authorization: `Bearer ${accessToken}` },
+    });
+    const json = await res.json();
+    if (!res.ok) throw new Error(`listWebhookSubscriptions failed: ${json?.error?.message || res.status}`);
+    return json?.data || [];
+}
+
+async function deleteWebhookSubscription(clientId: string, accessToken: string) {
+    const url = `https://graph.facebook.com/v19.0/${clientId}/subscriptions`;
+    const body = new URLSearchParams({ object: 'whatsapp_business_account' }).toString();
+    const res = await fetch(url, {
+        method: 'DELETE',
+        headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/x-www-form-urlencoded' },
+        body,
+    });
+    if (!res.ok) {
+        const json = await res.json().catch(() => ({}));
+        throw new Error(`deleteWebhookSubscription failed: ${json?.error?.message || res.status}`);
+    }
+    return true;
+}
+
+async function createWebhookSubscription(
+    clientId: string,
+    accessToken: string,
+    params: { callback_url: string; verify_token: string; fields: string[] }
+) {
+    const url = `https://graph.facebook.com/v19.0/${clientId}/subscriptions`;
+    const body = new URLSearchParams({
+        object: 'whatsapp_business_account',
+        callback_url: params.callback_url,
+        verify_token: params.verify_token,
+        fields: JSON.stringify(params.fields),
+        include_values: 'true',
+    }).toString();
+
+    const res = await fetch(url, {
+        method: 'POST',
+        headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/x-www-form-urlencoded' },
+        body,
+    });
+    const json = await res.json();
+    if (!res.ok) throw new Error(`createWebhookSubscription failed: ${json?.error?.message || res.status}`);
+    return json;
+}
+
+function extractFirstIncomingMessage(body: any): WhatsAppIncomingMessage | null {
+    try {
+        const entries = Array.isArray(body?.entry) ? body.entry : [];
+        for (const entry of entries) {
+            const changes = Array.isArray(entry?.changes) ? entry.changes : [];
+            for (const change of changes) {
+                const value = change?.value || {};
+                const messages = Array.isArray(value?.messages) ? value.messages : [];
+                if (!messages.length) continue;
+
+                const m = messages.find((x) => x?.text?.body) || messages[0] || {};
+                const contacts = Array.isArray(value?.contacts) ? value.contacts : [];
+                const contact = contacts.length ? contacts[0] : undefined;
+
+                const text = m?.text?.body || m?.button?.text || m?.interactive?.list_reply?.title || '';
+                const timestampIso = m?.timestamp ? new Date(parseInt(m.timestamp, 10) * 1000).toISOString() : undefined;
+
+                return {
+                    id: m?.id,
+                    from: m?.from || contact?.wa_id,
+                    profileName: contact?.profile?.name,
+                    text,
+                    type: m?.type,
+                    timestamp: timestampIso,
+                    phoneNumberId: value?.metadata?.phone_number_id,
+                };
+            }
+        }
+        return null;
+    } catch {
+        return null;
+    }
+}

package/src/Components/index.ts

@@ -42,6 +42,9 @@ import { MemoryWriteKeyVal } from './MemoryWriteKeyVal.class';
 import { MemoryReadKeyVal } from './MemoryReadKeyVal.class';
 import { MemoryDeleteKeyVal } from './MemoryDeleteKeyVal.class';
 import { MemoryWriteObject } from './MemoryWriteObject.class';
+import { GmailTrigger } from './Triggers/Gmail.trigger';
+import { WhatsAppTrigger } from './Triggers/WhatsApp.trigger';
+import { JobSchedulerTrigger } from './Triggers/JobScheduler.trigger';
 
 const components = {
     Component: new Component(),
@@ -92,6 +95,11 @@ const components = {
     MemoryReadKeyVal: new MemoryReadKeyVal(),
     MemoryDeleteKeyVal: new MemoryDeleteKeyVal(),
     MemoryWriteObject: new MemoryWriteObject(),
+
+    // Triggers
+    GmailTrigger: new GmailTrigger(),
+    WhatsAppTrigger: new WhatsAppTrigger(),
+    JobSchedulerTrigger: new JobSchedulerTrigger(),
 };
 
 export const ComponentInstances = components;

package/src/Core/AgentProcess.helper.ts

@@ -11,16 +11,14 @@ import fs from 'fs';
 import mime from 'mime';
 import path from 'path';
 import { ConnectorService } from './ConnectorsService';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
 
 export class AgentProcess {
     public agent: Agent;
 
     private _loadPromise: Promise<any>;
 
-    private constructor(
-        private agentData: any,
-        private agentVersion?: string,
-    ) {
+    private constructor(private agentData: any, private agentVersion?: string) {
         this.initAgent(agentData, agentVersion);
     }
     private async initAgent(agentData: any, agentVersion?: string) {
@@ -101,7 +99,7 @@ export class AgentProcess {
      */
     public async run(
         reqConfig: TAgentProcessParams | Array<string> | AgentRequest,
-        callback?: (data: any) => void,
+        callback?: (data: any) => void
     ): Promise<{
         status?: number;
         data: any;
@@ -116,7 +114,7 @@ export class AgentProcess {
             this.agent.setCallback(callback);
         }
 
-        const pathMatches = request.path.match(/(^\/v[0-9]+\.[0-9]+?)?(\/api\/(.+)?)/);
+        const pathMatches = request.path.match(/(^\/v[0-9]+\.[0-9]+?)?(\/(api|trigger)\/(.+)?)/);
         if (!pathMatches || !pathMatches[2]) {
             return { status: 404, data: { error: 'Endpoint not found' } };
         }

package/src/Core/Connector.class.ts

@@ -3,7 +3,7 @@ import { Logger } from '../helpers/Log.helper';
 import { createHash } from 'crypto';
 import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
 
-const console = Logger('Connector');
+const logger = Logger('Connector');
 //const lCache = new LocalCache();
 
 export class Connector<TRequest = any> {
@@ -68,12 +68,12 @@ export class Connector<TRequest = any> {
     }
 
     public async start() {
-        console.info(`Starting ${this.name} connector ...`);
+        logger.info(`Starting ${this.name} connector ...`);
         this.started = true;
     }
 
     public async stop() {
-        console.info(`Stopping ${this.name} connector ...`);
+        logger.info(`Stopping ${this.name} connector ...`);
     }
 
     public ready() {
@@ -110,6 +110,10 @@ export class Connector<TRequest = any> {
         if (typeof candidate === 'string') {
             return this.requester(AccessCandidate.user(candidate));
         }
+
+        //backward compatibility
+        //this will be deprecated in the future, use .requester for this case
+        // .user will only accept strings representing the user id
         return this.requester(candidate);
     }
 
@@ -120,4 +124,8 @@ export class Connector<TRequest = any> {
     public agent(agentId: string): TRequest {
         return this.requester(AccessCandidate.agent(agentId));
     }
+
+    public handleEvent(eventName: string, data: any): void {
+        logger.debug(`Connector ${this.name} received event ${eventName} `);
+    }
 }

package/src/Core/ConnectorsService.ts

@@ -19,6 +19,7 @@ import { LogConnector } from '@sre/IO/Log.service/LogConnector';
 import { ComponentConnector } from '@sre/AgentManager/Component.service/ComponentConnector';
 import { ModelsProviderConnector } from '@sre/LLMManager/ModelsProvider.service/ModelsProviderConnector';
 import { CodeConnector } from '@sre/ComputeManager/Code.service/CodeConnector';
+import { SchedulerConnector } from '@sre/AgentManager/Scheduler.service/SchedulerConnector';
 const console = Logger('ConnectorService');
 
 let ServiceRegistry: TServiceRegistry = {};
@@ -186,6 +187,10 @@ export class ConnectorService {
     static getCodeConnector(name?: string): CodeConnector {
         return ConnectorService.getInstance<CodeConnector>(TConnectorService.Code, name);
     }
+
+    static getSchedulerConnector(name?: string): SchedulerConnector {
+        return ConnectorService.getInstance<SchedulerConnector>(TConnectorService.Scheduler, name);
+    }
 }
 
 export abstract class ConnectorServiceProvider {