n8n-nodes-cribops 0.1.5

package/dist/nodes/CribopsTrigger/CribopsTrigger.node.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CribopsTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const CribopsHttp_1 = require("../../utils/CribopsHttp");
+class CribopsTrigger {
+    description = {
+        displayName: 'Cribops Trigger',
+        name: 'cribopsTrigger',
+        icon: 'file:cribopstrigger.svg',
+        group: ['trigger'],
+        version: 1,
+        description: 'Triggers when receiving messages from Cribops agents',
+        defaults: {
+            name: 'Cribops Trigger',
+        },
+        inputs: [],
+        outputs: ["main" /* NodeConnectionType.Main */],
+        credentials: [
+            {
+                name: 'cribopsApi',
+                required: true,
+            },
+        ],
+        webhooks: [
+            {
+                name: 'default',
+                httpMethod: 'POST',
+                responseMode: 'onReceived',
+                // Dynamic path to trigger UUID generation
+                path: '={{$parameter["agentId"]}}',
+            },
+        ],
+        properties: [
+            {
+                displayName: 'Agent Name or ID',
+                name: 'agentId',
+                type: 'options',
+                required: true,
+                typeOptions: {
+                    loadOptionsMethod: 'getAgents',
+                },
+                default: '',
+                description: 'The Cribops agent to receive messages from. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
+            },
+            {
+                displayName: 'Event Types',
+                name: 'eventTypes',
+                type: 'multiOptions',
+                options: [
+                    {
+                        name: 'Agent Response',
+                        value: 'agent_response',
+                        description: 'Responses from agents',
+                    },
+                    {
+                        name: 'User Message',
+                        value: 'user_message',
+                        description: 'Messages from users',
+                    },
+                    {
+                        name: 'File Attachment',
+                        value: 'file_attachment',
+                        description: 'File attachments',
+                    },
+                ],
+                default: ['user_message'],
+                description: 'Types of events to trigger on',
+            },
+            {
+                displayName: 'Additional Fields',
+                name: 'additionalFields',
+                type: 'collection',
+                placeholder: 'Add Field',
+                default: {},
+                options: [
+                    {
+                        displayName: 'Secret Token',
+                        name: 'secretToken',
+                        type: 'string',
+                        typeOptions: {
+                            password: true,
+                        },
+                        default: '',
+                        description: 'Secret token for webhook authentication',
+                    },
+                ],
+            },
+        ],
+    };
+    methods = {
+        loadOptions: {
+            async getAgents() {
+                const credentials = await this.getCredentials('cribopsApi');
+                const cribopsHttp = new CribopsHttp_1.CribopsHttp({
+                    baseUrl: credentials.baseUrl,
+                    apiToken: credentials.apiToken,
+                });
+                try {
+                    const agents = await cribopsHttp.getAgents();
+                    return agents.map((agent) => ({
+                        name: agent.name,
+                        value: agent.id,
+                        description: `ID: ${agent.id}`,
+                    }));
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load agents: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+        },
+    };
+    webhookMethods = {
+        default: {
+            async checkExists() {
+                const webhookUrl = this.getNodeWebhookUrl('default');
+                const agentId = this.getNodeParameter('agentId');
+                const credentials = await this.getCredentials('cribopsApi');
+                const cribopsHttp = new CribopsHttp_1.CribopsHttp({
+                    baseUrl: credentials.baseUrl,
+                    apiToken: credentials.apiToken,
+                });
+                try {
+                    // Check if webhook exists for this agent
+                    // This would need to be implemented in your Cribops API
+                    // For now, return false to always create
+                    return false;
+                }
+                catch (error) {
+                    return false;
+                }
+            },
+            async create() {
+                const webhookUrl = this.getNodeWebhookUrl('default');
+                const agentId = this.getNodeParameter('agentId');
+                const eventTypes = this.getNodeParameter('eventTypes', []);
+                const additionalFields = this.getNodeParameter('additionalFields', {});
+                const credentials = await this.getCredentials('cribopsApi');
+                const cribopsHttp = new CribopsHttp_1.CribopsHttp({
+                    baseUrl: credentials.baseUrl,
+                    apiToken: credentials.apiToken,
+                });
+                try {
+                    // Register webhook with Cribops
+                    // This is a placeholder - implement actual API call
+                    const body = {
+                        url: webhookUrl,
+                        agent_id: agentId,
+                        event_types: eventTypes,
+                        secret: additionalFields.secretToken || undefined,
+                    };
+                    // TODO: Make actual API call to register webhook
+                    // await cribopsHttp.registerWebhook(agentId, body);
+                    // Store webhook data for later use
+                    const webhookData = this.getWorkflowStaticData('node');
+                    webhookData.webhookId = `webhook_${agentId}_${Date.now()}`;
+                    webhookData.agentId = agentId;
+                    return true;
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to register webhook: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            },
+            async delete() {
+                const webhookData = this.getWorkflowStaticData('node');
+                const credentials = await this.getCredentials('cribopsApi');
+                if (!webhookData.webhookId) {
+                    return true;
+                }
+                const cribopsHttp = new CribopsHttp_1.CribopsHttp({
+                    baseUrl: credentials.baseUrl,
+                    apiToken: credentials.apiToken,
+                });
+                try {
+                    // Unregister webhook from Cribops
+                    // TODO: Make actual API call to unregister webhook
+                    // await cribopsHttp.deleteWebhook(webhookData.agentId, webhookData.webhookId);
+                    delete webhookData.webhookId;
+                    delete webhookData.agentId;
+                    return true;
+                }
+                catch (error) {
+                    return false;
+                }
+            },
+        },
+    };
+    async trigger() {
+        // Minimal implementation - webhooks are handled by webhook() method
+        return {
+            closeFunction: async () => { },
+            manualTriggerFunction: async () => {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This node only works with webhooks. Please activate the workflow.');
+            },
+        };
+    }
+    async webhook() {
+        const body = this.getBodyData();
+        const headers = this.getHeaderData();
+        const eventTypes = this.getNodeParameter('eventTypes', []);
+        const additionalFields = this.getNodeParameter('additionalFields', {});
+        const agentId = this.getNodeParameter('agentId');
+        // Validate secret token if provided
+        if (additionalFields.secretToken) {
+            const receivedToken = headers['x-cribops-signature'] || headers['authorization'];
+            if (receivedToken !== additionalFields.secretToken) {
+                return {
+                    webhookResponse: {
+                        status: 401,
+                        body: { error: 'Unauthorized' },
+                    },
+                };
+            }
+        }
+        // Filter by event type
+        if (eventTypes.length > 0 && body.type && !eventTypes.includes(body.type)) {
+            return {
+                webhookResponse: {
+                    status: 200,
+                    body: { received: true, filtered: true },
+                },
+            };
+        }
+        // Enrich the output with agent_id and other useful metadata
+        const outputData = {
+            ...body,
+            agent_id: agentId,
+            // Ensure conversation_id is available (handle different field names)
+            conversation_id: body.conversation_id || body.conversationId || body.thread_id,
+            // Ensure response_webhook is available if it exists
+            response_webhook: body.response_webhook || body.responseWebhook || body.callback_url,
+        };
+        // Log what we're outputting for debugging
+        console.log('CribopsTrigger output:', JSON.stringify(outputData, null, 2));
+        // Return the data to the workflow
+        return {
+            workflowData: [
+                [
+                    {
+                        json: outputData,
+                        headers,
+                    },
+                ],
+            ],
+        };
+    }
+}
+exports.CribopsTrigger = CribopsTrigger;

package/dist/nodes/CribopsTrigger/cribopstrigger.svg

@@ -0,0 +1,8 @@
+<svg width="60" height="60" viewBox="0 0 60 60" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <rect width="60" height="60" rx="12" fill="#059669"/>
+  <path d="M15 20C15 17.7909 16.7909 16 19 16H41C43.2091 16 45 17.7909 45 20V32C45 34.2091 43.2091 36 41 36H26L18 42V36H19C16.7909 36 15 34.2091 15 32V20Z" fill="white"/>
+  <path d="M20 24L28 28L20 32V24Z" fill="#059669"/>
+  <rect x="32" y="24" width="8" height="2" fill="#059669"/>
+  <rect x="32" y="28" width="8" height="2" fill="#059669"/>
+  <rect x="32" y="32" width="6" height="2" fill="#059669"/>
+</svg>

package/dist/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "n8n-nodes-cribops",
+  "version": "0.1.5",
+  "description": "n8n community node for Cribops AI platform integration",
+  "keywords": [
+    "n8n-community-node-package"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "CloudBedrock",
+    "email": "support@cloudbedrock.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CloudBedrock/n8n-nodes-cribops.git"
+  },
+  "homepage": "https://cribops.com",
+  "bugs": {
+    "url": "https://github.com/CloudBedrock/n8n-nodes-cribops/issues"
+  },
+  "engines": {
+    "node": ">=20.15"
+  },
+  "scripts": {
+    "build": "npx rimraf dist && tsc && gulp build:icons && cp package.json dist/",
+    "dev": "tsc --watch",
+    "format": "prettier nodes credentials --write",
+    "lint": "eslint nodes/**/*.ts credentials/**/*.ts --ext .ts",
+    "lintfix": "eslint nodes/**/*.ts credentials/**/*.ts --ext .ts --fix",
+    "prepublishOnly": "npm run build && npm run lint",
+    "test": "npm run build && n8n-node-dev test"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/CribopsApi.credentials.js"
+    ],
+    "nodes": [
+      "dist/nodes/Cribops/Cribops.node.js",
+      "dist/nodes/CribopsTrigger/CribopsTrigger.node.js"
+    ]
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.12",
+    "@typescript-eslint/parser": "~8.32.0",
+    "eslint": "^8.57.0",
+    "eslint-plugin-n8n-nodes-base": "^1.16.3",
+    "gulp": "^5.0.0",
+    "n8n-workflow": "^1.82.0",
+    "prettier": "^3.5.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.8.3",
+    "@aws-sdk/client-sqs": "^3.729.0",
+    "@aws-sdk/client-sns": "^3.729.0"
+  }
+}

package/dist/utils/CribopsHttp.d.ts

@@ -0,0 +1,40 @@
+import { IDataObject } from 'n8n-workflow';
+export interface CribopsHttpConfig {
+    baseUrl: string;
+    apiToken: string;
+    timeout?: number;
+}
+export interface CribopsAgent {
+    id: string;
+    name: string;
+    description?: string;
+    status: 'active' | 'inactive';
+    tenantId: string;
+    organizationId: string;
+    metadata?: IDataObject;
+}
+export interface CribopsWebhookMessage {
+    id: string;
+    type: 'user_message' | 'agent_response';
+    content: string;
+    conversationId: string;
+    userId?: string;
+    agentId: string;
+    timestamp: string;
+    metadata?: IDataObject;
+    fileUrl?: string;
+    fileName?: string;
+    fileType?: string;
+}
+export declare class CribopsHttp {
+    private config;
+    constructor(config: CribopsHttpConfig);
+    private makeRequest;
+    getAgents(): Promise<CribopsAgent[]>;
+    getAgent(agentId: string): Promise<CribopsAgent>;
+    sendMessage(agentId: string, message: Partial<CribopsWebhookMessage>): Promise<CribopsWebhookMessage>;
+    downloadFile(fileUrl: string): Promise<Buffer>;
+    validateWebhook(payload: any, signature: string): Promise<boolean>;
+    testConnection(): Promise<boolean>;
+    sendTypingIndicator(agentId: string, conversationId: string, typing: boolean): Promise<any>;
+}

package/dist/utils/CribopsHttp.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CribopsHttp = void 0;
+class CribopsHttp {
+    config;
+    constructor(config) {
+        this.config = {
+            timeout: 30000,
+            ...config,
+        };
+    }
+    async makeRequest(method, endpoint, data, options) {
+        const url = `${this.config.baseUrl}${endpoint}`;
+        const requestHeaders = {
+            'Authorization': `Bearer ${this.config.apiToken}`,
+            'Content-Type': 'application/json',
+            'Accept': 'application/json',
+        };
+        if (options?.headers) {
+            Object.keys(options.headers).forEach(key => {
+                requestHeaders[key] = String(options.headers[key]);
+            });
+        }
+        try {
+            const response = await fetch(url, {
+                method,
+                headers: requestHeaders,
+                body: data ? JSON.stringify(data) : undefined,
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            const result = await response.json();
+            return result;
+        }
+        catch (error) {
+            throw new Error(`Request failed: ${error}`);
+        }
+    }
+    async getAgents() {
+        try {
+            const response = await this.makeRequest('GET', '/api/v1/agents');
+            return response.agents || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch agents: ${error}`);
+        }
+    }
+    async getAgent(agentId) {
+        try {
+            const response = await this.makeRequest('GET', `/api/v1/agents/${agentId}`);
+            return response.agent;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch agent ${agentId}: ${error}`);
+        }
+    }
+    async sendMessage(agentId, message) {
+        try {
+            const response = await this.makeRequest('POST', `/webhooks/agents/${agentId}/message`, message);
+            return response.message;
+        }
+        catch (error) {
+            throw new Error(`Failed to send message to agent ${agentId}: ${error}`);
+        }
+    }
+    async downloadFile(fileUrl) {
+        try {
+            const response = await fetch(fileUrl, {
+                headers: {
+                    'Authorization': `Bearer ${this.config.apiToken}`,
+                },
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        catch (error) {
+            throw new Error(`Failed to download file: ${error}`);
+        }
+    }
+    async validateWebhook(payload, signature) {
+        // Implement webhook signature validation if needed
+        // This would typically use HMAC verification
+        return true;
+    }
+    async testConnection() {
+        try {
+            await this.getAgents();
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    async sendTypingIndicator(agentId, conversationId, typing) {
+        try {
+            const response = await this.makeRequest('POST', `/api/agents/${agentId}/callback`, {
+                data: {
+                    typing: typing,
+                },
+                conversation_id: conversationId,
+                callback_type: 'typing',
+            });
+            return response;
+        }
+        catch (error) {
+            throw new Error(`Failed to send typing indicator for agent ${agentId}: ${error}`);
+        }
+    }
+}
+exports.CribopsHttp = CribopsHttp;

package/dist/utils/FileUtils.d.ts

@@ -0,0 +1,36 @@
+import { IDataObject } from 'n8n-workflow';
+export interface FileAttachment {
+    url: string;
+    name: string;
+    type: string;
+    size?: number;
+    data?: Buffer;
+}
+export interface S3PresignedUrl {
+    uploadUrl: string;
+    downloadUrl: string;
+    fileName: string;
+    fileType: string;
+    expiresAt: string;
+}
+export declare class FileUtils {
+    private static readonly SUPPORTED_TYPES;
+    private static readonly MAX_FILE_SIZE;
+    static validateFileType(fileType: string): boolean;
+    static validateFileSize(size: number): boolean;
+    static extractFileInfo(url: string): {
+        name: string;
+        type: string;
+    };
+    static downloadFileFromUrl(url: string, headers?: IDataObject): Promise<Buffer>;
+    static formatFileSize(bytes: number): string;
+    static isImageFile(fileType: string): boolean;
+    static isTextFile(fileType: string): boolean;
+    static convertToBase64(buffer: Buffer): Promise<string>;
+    static convertFromBase64(base64: string): Promise<Buffer>;
+    static sanitizeFileName(fileName: string): string;
+    static generateUniqueFileName(originalName: string): string;
+    static parseS3PresignedUrl(url: string): S3PresignedUrl | null;
+    static validateFileContent(buffer: Buffer, expectedType: string): Promise<boolean>;
+    static createFileAttachment(url: string, name?: string, type?: string, size?: number): FileAttachment;
+}

package/dist/utils/FileUtils.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUtils = void 0;
+class FileUtils {
+    static SUPPORTED_TYPES = [
+        'image/jpeg',
+        'image/png',
+        'image/gif',
+        'image/webp',
+        'text/plain',
+        'text/csv',
+        'application/pdf',
+        'application/json',
+        'application/xml',
+        'application/zip',
+        'application/x-zip-compressed',
+        'application/msword',
+        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+        'application/vnd.ms-excel',
+        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    ];
+    static MAX_FILE_SIZE = 10 * 1024 * 1024; // 10MB
+    static validateFileType(fileType) {
+        return this.SUPPORTED_TYPES.includes(fileType.toLowerCase());
+    }
+    static validateFileSize(size) {
+        return size <= this.MAX_FILE_SIZE;
+    }
+    static extractFileInfo(url) {
+        const urlParts = url.split('/');
+        const fileName = urlParts[urlParts.length - 1];
+        const fileExtension = fileName.split('.').pop()?.toLowerCase() || '';
+        const typeMapping = {
+            'jpg': 'image/jpeg',
+            'jpeg': 'image/jpeg',
+            'png': 'image/png',
+            'gif': 'image/gif',
+            'webp': 'image/webp',
+            'txt': 'text/plain',
+            'csv': 'text/csv',
+            'pdf': 'application/pdf',
+            'json': 'application/json',
+            'xml': 'application/xml',
+            'zip': 'application/zip',
+            'doc': 'application/msword',
+            'docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+            'xls': 'application/vnd.ms-excel',
+            'xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+        };
+        return {
+            name: fileName,
+            type: typeMapping[fileExtension] || 'application/octet-stream',
+        };
+    }
+    static async downloadFileFromUrl(url, headers) {
+        try {
+            const requestHeaders = {};
+            if (headers) {
+                Object.keys(headers).forEach(key => {
+                    requestHeaders[key] = String(headers[key]);
+                });
+            }
+            const response = await fetch(url, {
+                headers: requestHeaders,
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const arrayBuffer = await response.arrayBuffer();
+            return Buffer.from(arrayBuffer);
+        }
+        catch (error) {
+            throw new Error(`Failed to download file from URL: ${error}`);
+        }
+    }
+    static formatFileSize(bytes) {
+        if (bytes === 0)
+            return '0 Bytes';
+        const k = 1024;
+        const sizes = ['Bytes', 'KB', 'MB', 'GB'];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    }
+    static isImageFile(fileType) {
+        return fileType.startsWith('image/');
+    }
+    static isTextFile(fileType) {
+        return fileType.startsWith('text/') || fileType.includes('json') || fileType.includes('xml');
+    }
+    static async convertToBase64(buffer) {
+        return buffer.toString('base64');
+    }
+    static async convertFromBase64(base64) {
+        return Buffer.from(base64, 'base64');
+    }
+    static sanitizeFileName(fileName) {
+        // Remove or replace invalid characters
+        return fileName
+            .replace(/[^a-zA-Z0-9._-]/g, '_')
+            .replace(/_{2,}/g, '_')
+            .replace(/^_|_$/g, '');
+    }
+    static generateUniqueFileName(originalName) {
+        const timestamp = Date.now();
+        const randomSuffix = Math.random().toString(36).substring(2, 8);
+        const sanitizedName = this.sanitizeFileName(originalName);
+        const parts = sanitizedName.split('.');
+        if (parts.length > 1) {
+            const extension = parts.pop();
+            const baseName = parts.join('.');
+            return `${baseName}_${timestamp}_${randomSuffix}.${extension}`;
+        }
+        else {
+            return `${sanitizedName}_${timestamp}_${randomSuffix}`;
+        }
+    }
+    static parseS3PresignedUrl(url) {
+        try {
+            const urlObj = new URL(url);
+            const pathParts = urlObj.pathname.split('/');
+            const fileName = pathParts[pathParts.length - 1];
+            const fileInfo = this.extractFileInfo(fileName);
+            return {
+                uploadUrl: url,
+                downloadUrl: url,
+                fileName: fileInfo.name,
+                fileType: fileInfo.type,
+                expiresAt: urlObj.searchParams.get('X-Amz-Expires') || '',
+            };
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    static async validateFileContent(buffer, expectedType) {
+        // Basic file content validation
+        if (buffer.length === 0) {
+            return false;
+        }
+        // Check file signatures (magic numbers) for common types
+        const fileSignatures = {
+            'image/jpeg': [[0xFF, 0xD8, 0xFF]],
+            'image/png': [[0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]],
+            'image/gif': [[0x47, 0x49, 0x46, 0x38]],
+            'application/pdf': [[0x25, 0x50, 0x44, 0x46]],
+            'application/zip': [[0x50, 0x4B, 0x03, 0x04], [0x50, 0x4B, 0x05, 0x06]],
+        };
+        const signatures = fileSignatures[expectedType];
+        if (!signatures) {
+            return true; // No signature check available, assume valid
+        }
+        const fileHeader = Array.from(buffer.slice(0, 8));
+        return signatures.some(signature => signature.every((byte, index) => fileHeader[index] === byte));
+    }
+    static createFileAttachment(url, name, type, size) {
+        const fileInfo = name && type ? { name, type } : this.extractFileInfo(url);
+        return {
+            url,
+            name: fileInfo.name,
+            type: fileInfo.type,
+            size,
+        };
+    }
+}
+exports.FileUtils = FileUtils;