@smythos/sre 1.6.1 → 1.6.9

package/dist/types/Components/Triggers/Gmail.trigger.d.ts

@@ -0,0 +1,58 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+export type GmailTriggerAttachment = {
+    filename: string;
+    mimeType: string;
+    size: number;
+    attachmentId: string;
+};
+export type GmailTriggerMessage = {
+    id: string;
+    threadId: string;
+    labelIds: string[];
+    snippet: string;
+    sizeEstimate: number;
+    internalDate: string;
+    headers: {
+        from: string;
+        to: string;
+        cc: string;
+        bcc: string;
+        subject: string;
+        date: string;
+        messageId: string;
+    };
+    body: {
+        text: string;
+        html: string;
+    };
+    attachments: GmailTriggerAttachment[];
+    isUnread: true;
+};
+export declare class GmailTrigger extends Trigger {
+    collectPayload(input: any, config: any, agent: Agent): Promise<{
+        email: {
+            id: any;
+            threadId: any;
+            labelIds: any;
+            snippet: any;
+            sizeEstimate: any;
+            internalDate: string;
+            headers: {
+                from: any;
+                to: any;
+                cc: any;
+                bcc: any;
+                subject: any;
+                date: any;
+                messageId: any;
+            };
+            body: {
+                text: string;
+                html: string;
+            };
+            attachments: any[];
+            isUnread: any;
+        };
+    }[]>;
+}

package/dist/types/Components/Triggers/GmailTrigger.class.d.ts

@@ -1,13 +1,44 @@
 import { IAgent as Agent } from '@sre/types/Agent.types';
 import { Trigger } from './Trigger.class';
+export type GmailTriggerAttachment = {
+    filename: string;
+    mimeType: string;
+    size: number;
+    attachmentId: string;
+};
+export type GmailTriggerMessage = {
+    id: string;
+    threadId: string;
+    labelIds: string[];
+    snippet: string;
+    sizeEstimate: number;
+    internalDate: string;
+    headers: {
+        from: string;
+        to: string;
+        cc: string;
+        bcc: string;
+        subject: string;
+        date: string;
+        messageId: string;
+    };
+    body: {
+        text: string;
+        html: string;
+    };
+    attachments: GmailTriggerAttachment[];
+    isUnread: true;
+};
 export declare class GmailTrigger extends Trigger {
-    init(): void;
-    process(input: any, config: any, agent: Agent): Promise<{
-        Payload: {};
-        Result: any;
-        _temp_result: any;
-        _error: any;
-        _in_progress: boolean;
-        _debug: string;
-    }>;
+    collectPayload(input: any, config: any, agent: Agent): Promise<{
+        message: {
+            id: string;
+            subject: string;
+            body: string;
+            from: string;
+            to: string;
+            date: string;
+            threadId: string;
+        };
+    }[]>;
 }

package/dist/types/Components/Triggers/Trigger.class.d.ts

@@ -1,3 +1,21 @@
+import { Agent } from '@sre/AgentManager/Agent.class';
 import { Component } from '../Component.class';
+import { LogHelper } from '@sre/helpers/Log.helper';
 export declare class Trigger extends Component {
+    protected logger: LogHelper;
+    process(input: any, settings: any, agent: Agent): Promise<any>;
+    protected collectPayload(input: any, settings: any, agent: Agent): Promise<any[]>;
+    requestHandler(input: any, settings: any, agent: Agent): Promise<any>;
+    protected processIteration(inputArray: any, settings: any, agent: any): Promise<{
+        Payload: {};
+        Result: any;
+        _temp_result: any;
+        _error: any;
+        _in_progress: boolean;
+        _debug: string;
+    }>;
+    postProcess(output: any, settings: any, agent: Agent): Promise<any>;
+    register(componentId: string, componentSettings: any, payload: {
+        triggerUrl: string;
+    }): Promise<void>;
 }

package/dist/types/Components/Triggers/WhatsApp.trigger.d.ts

@@ -0,0 +1,22 @@
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Trigger } from './Trigger.class';
+type WhatsAppIncomingMessage = {
+    id?: string;
+    from?: string;
+    profileName?: string;
+    text?: string;
+    type?: string;
+    timestamp?: string;
+    phoneNumberId?: string;
+};
+export declare class WhatsAppTrigger extends Trigger {
+    collectPayload(input: any, settings: any, agent: Agent): Promise<{
+        message: WhatsAppIncomingMessage;
+    }[]>;
+    requestHandler(input: any, settings: any, agent: Agent): Promise<boolean>;
+    register(componentId: string, componentSettings: any, payload?: {
+        triggerUrl: string;
+    }): Promise<void>;
+    unregister(componentId: string, agent: Agent, payload?: any): Promise<void>;
+}
+export {};

package/dist/types/subsystems/Security/Credentials/Credentials.class.d.ts

@@ -0,0 +1,2 @@
+export declare class Credentials {
+}

package/dist/types/subsystems/Security/Credentials/ManagedOAuth2Credentials.class.d.ts

@@ -0,0 +1,18 @@
+import { Credentials } from './Credentials.class';
+import { AccessCandidate } from '../AccessControl/AccessCandidate.class';
+export declare class ManagedOAuth2Credentials extends Credentials {
+    #private;
+    get accessToken(): string;
+    get refreshToken(): string;
+    get expiresIn(): number;
+    get scope(): string;
+    get tokenUrl(): string;
+    get service(): string;
+    private constructor();
+    static load(keyId: string, candidate: AccessCandidate): Promise<ManagedOAuth2Credentials>;
+    private parseData;
+    /**
+     * Get a fresh access token using the refresh token
+     */
+    refreshAccessToken(): Promise<string>;
+}

package/dist/types/subsystems/Security/Credentials/OAuth2Credentials.class.d.ts

@@ -0,0 +1,14 @@
+import { Credentials } from './Credentials.class';
+import { AccessCandidate } from '../AccessControl/AccessCandidate.class';
+export declare class OAuth2Credentials extends Credentials {
+    #private;
+    accessToken: string;
+    refreshToken: string;
+    expiresIn: number;
+    scope: string;
+    tokenUrl: string;
+    service: string;
+    constructor(data: any);
+    static fromManagedVault(keyId: string, candidate: AccessCandidate): Promise<OAuth2Credentials>;
+    private parseData;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smythos/sre",
-  "version": "1.6.1",
+  "version": "1.6.9",
   "description": "Smyth Runtime Environment",
   "author": "Alaa-eddine KADDOURI",
   "license": "MIT",

package/src/helpers/AWSLambdaCode.helper.ts

@@ -187,6 +187,7 @@ export async function createOrUpdateLambdaFunction(functionName, zipFilePath, aw
                         AssumeRolePolicyDocument: getLambdaRolePolicy(),
                     });
                     const roleResponse: CreateRoleCommandOutput = await iamClient.send(createRoleCommand);
+                 
                     await waitForRoleDeploymentStatus(`smyth-${functionName}-role`, iamClient);
                     roleArn = roleResponse.Role.Arn;
                 } else {
@@ -208,14 +209,9 @@ export async function createOrUpdateLambdaFunction(functionName, zipFilePath, aw
                 MemorySize: 256,
                 ...(envVariables && Object.keys(envVariables).length ? { Environment: { Variables: envVariables } } : {}),
             };
-
-            const functionCreateCommand = new CreateFunctionCommand(functionParams);
-            await client.send(functionCreateCommand);
-            // console.log('Function ARN:', functionResponse.FunctionArn);
+            // Retry mechanism for Lambda function creation with exponential backoff
+            await createLambdaFunction(client, functionParams);
             await verifyFunctionDeploymentStatus(functionName, client);
-            // wait 500 ms to let the function trust policy be applied
-            // it will only occur when the function is created for the first time
-            await new Promise((resolve) => setTimeout(resolve, 500));
         }
     } catch (error) {
         throw error;
@@ -233,20 +229,49 @@ function updateLambdaFunctionConfiguration(client: LambdaClient, functionName: s
     return client.send(updateFunctionConfigurationCommand);
 }
 
+async function createLambdaFunction(client: LambdaClient, functionParams: any, maxRetries: number = 5): Promise<void> {
+    let lastError: Error | null = null;
+    
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            const functionCreateCommand = new CreateFunctionCommand(functionParams);
+            await client.send(functionCreateCommand);
+            return; // Success, exit the retry loop
+        } catch (error) {
+            lastError = error;
+            // Check if this is a role trust policy error
+            if (error?.message?.includes('cannot be assumed by Lambda')) {
+                
+                if (attempt < maxRetries) {
+                    // Exponential backoff: 2^attempt seconds (2, 4, 8, 16, 32 seconds)
+                    const waitTime = Math.pow(2, attempt) * 1000;
+                    await new Promise(resolve => setTimeout(resolve, waitTime));
+                    continue;
+                }
+            }
+            
+            // For other errors or if we've exhausted retries, throw immediately
+            throw error;
+        }
+    }
+    
+    // If we get here, all retries failed
+    throw lastError || new Error('Lambda function creation failed after all retry attempts');
+}
+
 export async function waitForRoleDeploymentStatus(roleName, client): Promise<boolean> {
     return new Promise((resolve, reject) => {
-        try {
-            let interval = setInterval(async () => {
+        const interval = setInterval(async () => {
                 const getRoleCommand = new GetRoleCommand({ RoleName: roleName });
                 const roleResponse = await client.send(getRoleCommand);
-                if (roleResponse.Role.AssumeRolePolicyDocument) {
+
+                // Check if role exists and has assume role policy document
+                if (roleResponse.Role && roleResponse.Role.AssumeRolePolicyDocument) {
                     clearInterval(interval);
-                    return resolve(true);
+                    setTimeout(() => resolve(true), 2000);
+                    return;
                 }
-            }, 7000);
-        } catch (error) {
-            return false;
-        }
+        }, 2000); // Check every 2 seconds
     });
 }