feat: add n8n, langchain and copilot-studio connector functionality

apps/dashboard/src/main/java/com/akto/action/AIAgentConnectorImportAction.java

@@ -0,0 +1,143 @@
+package com.akto.action;
+
+import com.akto.dao.context.Context;
+import com.akto.dto.jobs.AIAgentConnectorSyncJobParams;
+import com.akto.dto.jobs.Job;
+import com.akto.dto.jobs.JobExecutorType;
+import com.akto.jobs.JobScheduler;
+import com.akto.log.LoggerMaker;
+import com.akto.log.LoggerMaker.LogDb;
+import com.opensymphony.xwork2.Action;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import static com.akto.jobs.executors.AIAgentConnectorConstants.*;
+import static com.akto.jobs.executors.AIAgentConnectorUtils.*;
+
+/**
+ * Unified action for importing AI Agent Connector data (N8N, Langchain, Copilot Studio).
+ * This action schedules recurring jobs to sync data from various AI agent platforms.
+ */
+@Getter
+@Setter
+public class AIAgentConnectorImportAction extends UserAction {
+
+    private static final LoggerMaker loggerMaker = new LoggerMaker(AIAgentConnectorImportAction.class, LogDb.DASHBOARD);
+
+    // Action parameters
+    private String connectorType;
+    private String dataIngestionUrl;
+    private String jobId;
+    private Integer recurringIntervalSeconds;
+
+    // N8N-specific parameters
+    private String n8nUrl;
+    private String n8nApiKey;
+
+    // Langchain-specific parameters
+    private String langsmithUrl;
+    private String langsmithApiKey;
+
+    // Copilot Studio-specific parameters
+    private String appInsightsAppId;
+    private String appInsightsApiKey;
+
+    /**
+     * Unified method to initiate import for any AI Agent Connector.
+     * The connector type is determined by the connectorType parameter.
+     */
+    public String initiateImport() {
+        try {
+            loggerMaker.info("Initiating import for connector type: " + connectorType, LogDb.DASHBOARD);
+
+            // Validate connector type
+            if (!isValidConnectorType(connectorType)) {
+                loggerMaker.error("Invalid connector type: " + connectorType, LogDb.DASHBOARD);
+                return Action.ERROR.toUpperCase();
+            }
+
+            // Build configuration based on connector type
+            Map<String, String> config = buildConfig();
+            if (config == null) {
+                return Action.ERROR.toUpperCase();
+            }
+
+            // Determine recurring interval (use provided value or default)
+            int interval = (recurringIntervalSeconds != null && recurringIntervalSeconds > 0)
+                ? recurringIntervalSeconds
+                : DEFAULT_RECURRING_INTERVAL_SECONDS;
+
+            // Schedule recurring job using JobScheduler
+            Job job = JobScheduler.scheduleRecurringJob(
+                Context.accountId.get(),
+                new AIAgentConnectorSyncJobParams(
+                    connectorType,
+                    config,
+                    Context.now()
+                ),
+                JobExecutorType.DASHBOARD,
+                interval
+            );
+
+            if (job == null) {
+                loggerMaker.error("Failed to schedule recurring job for " + connectorType + " connector", LogDb.DASHBOARD);
+                return Action.ERROR.toUpperCase();
+            }
+
+            this.jobId = job.getId().toHexString();
+            loggerMaker.info("Successfully scheduled recurring job for " + connectorType + " connector with job ID: " + this.jobId + ", interval: " + interval + "s", LogDb.DASHBOARD);
+
+            return Action.SUCCESS.toUpperCase();
+
+        } catch (Exception e) {
+            loggerMaker.error("Error initiating " + connectorType + " import: " + e.getMessage(), LogDb.DASHBOARD);
+            return Action.ERROR.toUpperCase();
+        }
+    }
+
+    /**
+     * Builds configuration map based on connector type.
+     */
+    private Map<String, String> buildConfig() {
+        Map<String, String> config = new HashMap<>();
+        config.put(CONFIG_DATA_INGESTION_SERVICE_URL, dataIngestionUrl);
+
+        switch (connectorType) {
+            case CONNECTOR_TYPE_N8N:
+                if (n8nUrl == null || n8nUrl.isEmpty() || n8nApiKey == null || n8nApiKey.isEmpty()) {
+                    loggerMaker.error("Missing required N8N configuration", LogDb.DASHBOARD);
+                    return null;
+                }
+                config.put(CONFIG_N8N_BASE_URL, n8nUrl);
+                config.put(CONFIG_N8N_API_KEY, n8nApiKey);
+                break;
+
+            case CONNECTOR_TYPE_LANGCHAIN:
+                if (langsmithUrl == null || langsmithUrl.isEmpty() || langsmithApiKey == null || langsmithApiKey.isEmpty()) {
+                    loggerMaker.error("Missing required Langchain configuration", LogDb.DASHBOARD);
+                    return null;
+                }
+                config.put(CONFIG_LANGSMITH_BASE_URL, langsmithUrl);
+                config.put(CONFIG_LANGSMITH_API_KEY, langsmithApiKey);
+                break;
+
+            case CONNECTOR_TYPE_COPILOT_STUDIO:
+                if (appInsightsAppId == null || appInsightsAppId.isEmpty() || appInsightsApiKey == null || appInsightsApiKey.isEmpty()) {
+                    loggerMaker.error("Missing required Copilot Studio configuration", LogDb.DASHBOARD);
+                    return null;
+                }
+                config.put(CONFIG_APPINSIGHTS_APP_ID, appInsightsAppId);
+                config.put(CONFIG_APPINSIGHTS_API_KEY, appInsightsApiKey);
+                break;
+
+            default:
+                loggerMaker.error("Unsupported connector type: " + connectorType, LogDb.DASHBOARD);
+                return null;
+        }
+
+        return config;
+    }
+}

apps/dashboard/src/main/resources/struts.xml

@@ -3143,6 +3143,34 @@
             </result>
         </action>
 
+        <!-- Unified AI Agent Connector Import Action -->
+        <action name="api/initiateAIAgentConnectorImport" class="com.akto.action.AIAgentConnectorImportAction" method="initiateImport">
+            <interceptor-ref name="json"/>
+            <interceptor-ref name="defaultStack" />
+            <interceptor-ref name="roleAccessInterceptor">
+                <param name="featureLabel">INTEGRATIONS</param>
+                <param name="accessType">READ_WRITE</param>
+                <param name="actionDescription">User started AI Agent Connector Import</param>
+            </interceptor-ref>
+            <result name="FORBIDDEN" type="json">
+                <param name="statusCode">403</param>
+                <param name="ignoreHierarchy">false</param>
+                <param name="includeProperties">^actionErrors.*</param>
+            </result>
+            <result name="SUCCESS"  type="json">
+            </result>
+            <result name="ERROR" type="json">
+                <param name="statusCode">422</param>
+                <param name="ignoreHierarchy">false</param>
+                <param name="includeProperties">^actionErrors.*</param>
+            </result>
+            <result name="UNAUTHORIZED" type="json">
+                 <param name="statusCode">403</param>
+                 <param name="ignoreHierarchy">false</param>
+                 <param name="includeProperties">^actionErrors.*</param>
+            </result>
+        </action>
+
         <action name="api/initiateMCPRecon" class="com.akto.action.MCPReconAction" method="initiateMCPRecon">
             <interceptor-ref name="json"/>
             <interceptor-ref name="defaultStack" />

apps/dashboard/web/polaris_web/web/src/apps/dashboard/pages/quick_start/api.js

@@ -226,6 +226,19 @@ const api = {
         })
     },
 
+    initiateAIAgentConnectorImport(connectorType, connectorConfig, dataIngestionUrl, recurringIntervalSeconds) {
+        return request({
+            url: '/api/initiateAIAgentConnectorImport',
+            method: 'post',
+            data: {
+                connectorType,
+                dataIngestionUrl,
+                recurringIntervalSeconds,
+                ...connectorConfig
+            }
+        })
+    },
+
 }
 
 export default api

apps/dashboard/web/polaris_web/web/src/apps/dashboard/pages/quick_start/components/AIAgentConnectorImport.jsx

@@ -0,0 +1,137 @@
+import { Box, Button, ButtonGroup, Divider, Text, TextField, VerticalStack } from '@shopify/polaris';
+import React, { useState } from 'react';
+import api from '../api';
+import func from "@/util/func";
+import PasswordTextField from '../../../components/layouts/PasswordTextField';
+
+/**
+ * Common component for AI Agent Connector imports (N8N, Langchain, Copilot Studio)
+ */
+const AIAgentConnectorImport = ({
+    connectorType,
+    connectorName,
+    description,
+    fields,
+    docsUrl,
+    recurringIntervalSeconds = 300,
+    onSuccess
+}) => {
+    const [loading, setLoading] = useState(false);
+    const [formData, setFormData] = useState(
+        fields.reduce((acc, field) => ({ ...acc, [field.name]: '' }), {})
+    );
+
+    const goToDocs = () => {
+        window.open(docsUrl);
+    };
+
+    const validateForm = () => {
+        for (const field of fields) {
+            const value = formData[field.name];
+            if (!value || value.length === 0) {
+                func.setToast(true, true, `Please enter a valid ${field.label}.`);
+                return false;
+            }
+        }
+        return true;
+    };
+
+    const buildConnectorConfig = () => {
+        const config = {};
+        fields.forEach(field => {
+            if (field.configKey) {
+                config[field.configKey] = formData[field.name];
+            }
+        });
+        return config;
+    };
+
+    const primaryAction = () => {
+        if (!validateForm()) {
+            return;
+        }
+
+        setLoading(true);
+        const connectorConfig = buildConnectorConfig();
+        const dataIngestionUrl = formData.dataIngestionUrl;
+
+        api.initiateAIAgentConnectorImport(
+            connectorType,
+            connectorConfig,
+            dataIngestionUrl,
+            recurringIntervalSeconds
+        ).then((res) => {
+            func.setToast(true, false, `${connectorName} Import initiated successfully. Please check your dashboard for updates.`);
+            if (onSuccess) {
+                onSuccess(res);
+            }
+        }).catch((err) => {
+            console.error(`Error initiating ${connectorName} import:`, err);
+            func.setToast(true, true, `Ensure that you have added the correct ${connectorName} credentials.`);
+        }).finally(() => {
+            setLoading(false);
+            // Reset form
+            setFormData(fields.reduce((acc, field) => ({ ...acc, [field.name]: '' }), {}));
+        });
+    };
+
+    const isFormValid = () => {
+        return fields.every(field => formData[field.name]?.length > 0);
+    };
+
+    const updateField = (fieldName, value) => {
+        setFormData(prev => ({ ...prev, [fieldName]: value }));
+    };
+
+    return (
+        <div className='card-items'>
+            <Text variant='bodyMd'>
+                {description}
+            </Text>
+
+            <Box paddingBlockStart={3}><Divider /></Box>
+
+            <VerticalStack gap="2">
+                {fields.map((field) => {
+                    if (field.type === 'password') {
+                        return (
+                            <PasswordTextField
+                                key={field.name}
+                                label={field.label}
+                                setField={(value) => updateField(field.name, value)}
+                                onFunc={true}
+                                field={formData[field.name]}
+                                placeholder={field.placeholder}
+                            />
+                        );
+                    }
+
+                    return (
+                        <TextField
+                            key={field.name}
+                            label={field.label}
+                            value={formData[field.name]}
+                            type={field.type || 'text'}
+                            onChange={(value) => updateField(field.name, value)}
+                            placeholder={field.placeholder}
+                        />
+                    );
+                })}
+
+                <ButtonGroup>
+                    <Button
+                        onClick={primaryAction}
+                        primary
+                        disabled={!isFormValid()}
+                        loading={loading}
+                    >
+                        Import
+                    </Button>
+                    <Button onClick={goToDocs}>Go to docs</Button>
+                </ButtonGroup>
+            </VerticalStack>
+        </div>
+    );
+};
+
+export default AIAgentConnectorImport;