n8n-nodes-cribops 0.1.24 → 0.2.1

package/dist/nodes/CribopsTrigger/CribopsTrigger.node.d.ts

@@ -1,11 +1,6 @@
-import { INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData, IHookFunctions, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+import { INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData, IHookFunctions } from 'n8n-workflow';
 export declare class CribopsTrigger implements INodeType {
     description: INodeTypeDescription;
-    methods: {
-        loadOptions: {
-            getWebhooks(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
-        };
-    };
     webhookMethods: {
         default: {
             checkExists(this: IHookFunctions): Promise<boolean>;

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

@@ -5,14 +5,14 @@ const n8n_workflow_1 = require("n8n-workflow");
 const CribopsHttp_1 = require("../../utils/CribopsHttp");
 class CribopsTrigger {
     description = {
-        displayName: 'Cribops Trigger',
+        displayName: 'Cribops Webhook Trigger',
         name: 'cribopsTrigger',
         icon: 'file:cribopstrigger.svg',
         group: ['trigger'],
         version: 1,
-        description: 'Triggers when receiving messages via Cribops webhook',
+        description: 'Receive webhooks from Cribops queue at a controlled rate',
         defaults: {
-            name: 'Cribops Trigger',
+            name: 'Cribops Webhook Trigger',
         },
         inputs: [],
         outputs: ["main" /* NodeConnectionType.Main */],
@@ -27,167 +27,128 @@ class CribopsTrigger {
                 name: 'default',
                 httpMethod: 'POST',
                 responseMode: 'onReceived',
-                path: '={{$parameter["webhookId"]}}',
+                path: '={{$parameter["webhookPath"]}}',
                 isFullPath: false,
             },
         ],
         properties: [
             {
-                displayName: 'Webhook Name or ID',
-                name: 'webhookId',
-                type: 'options',
+                displayName: 'Webhook Path',
+                name: 'webhookPath',
+                type: 'string',
                 required: true,
-                typeOptions: {
-                    loadOptionsMethod: 'getWebhooks',
-                },
                 default: '',
-                description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
+                placeholder: 'my-webhook-endpoint',
+                description: 'The path for this webhook endpoint (will be appended to your n8n webhook URL)',
             },
             {
-                displayName: 'Event Types',
-                name: 'eventTypes',
-                type: 'multiOptions',
+                displayName: 'Options',
+                name: 'options',
+                type: 'collection',
+                placeholder: 'Add Option',
+                default: {},
                 options: [
                     {
-                        name: 'Agent Response',
-                        value: 'agent_response',
-                        description: 'Responses from agents',
+                        displayName: 'Include Cribops Metadata',
+                        name: 'includeCribopsMetadata',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Include Cribops tracking ID, queue info, and processing metadata',
                     },
                     {
-                        name: 'User Message',
-                        value: 'user_message',
-                        description: 'Messages from users',
+                        displayName: 'Include Original Headers',
+                        name: 'includeHeaders',
+                        type: 'boolean',
+                        default: false,
+                        description: 'Include the original webhook headers',
                     },
                     {
-                        name: 'File Attachment',
-                        value: 'file_attachment',
-                        description: 'File attachments',
+                        displayName: 'Report Performance',
+                        name: 'reportPerformance',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Automatically report processing time back to Cribops',
                     },
                     {
-                        name: 'System Event',
-                        value: 'system_event',
-                        description: 'System events and notifications',
+                        displayName: 'Report Errors',
+                        name: 'reportErrors',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Automatically report errors back to Cribops for monitoring',
+                    },
+                    {
+                        displayName: 'Validate Signature',
+                        name: 'validateSignature',
+                        type: 'boolean',
+                        default: true,
+                        description: 'Validate webhook signature from Cribops',
                     },
-                ],
-                default: ['user_message', 'agent_response'],
-                description: 'Types of events to trigger on',
-            },
-            {
-                displayName: 'Additional Fields',
-                name: 'additionalFields',
-                type: 'collection',
-                placeholder: 'Add Field',
-                default: {},
-                options: [
                     {
-                        displayName: 'Secret Token',
-                        name: 'secretToken',
+                        displayName: 'Signature Secret',
+                        name: 'signatureSecret',
                         type: 'string',
                         typeOptions: {
                             password: true,
                         },
+                        displayOptions: {
+                            show: {
+                                validateSignature: [true],
+                            },
+                        },
                         default: '',
-                        description: 'Secret token for webhook signature validation',
-                    },
-                    {
-                        displayName: 'Include Headers',
-                        name: 'includeHeaders',
-                        type: 'boolean',
-                        default: false,
-                        description: 'Whether to include the webhook headers in the output',
+                        description: 'Secret key shared with Cribops for signature validation',
                     },
                 ],
             },
         ],
     };
-    methods = {
-        loadOptions: {
-            async getWebhooks() {
-                const credentials = await this.getCredentials('cribopsApi');
-                const cribopsHttp = new CribopsHttp_1.CribopsHttp({
-                    baseUrl: credentials.baseUrl,
-                    apiToken: credentials.apiToken,
-                });
-                try {
-                    // Organization is automatically determined from API key
-                    const webhooks = await cribopsHttp.getWebhooks();
-                    // Filter for N8N type webhooks that are active and not linked
-                    const availableWebhooks = webhooks.filter((webhook) => webhook.type === 'N8N' &&
-                        webhook.status === 'active' &&
-                        !webhook.linked_workflow_id);
-                    return availableWebhooks.map((webhook) => ({
-                        name: webhook.name,
-                        value: webhook.id,
-                        description: webhook.description || `Type: ${webhook.type}`,
-                    }));
-                }
-                catch (error) {
-                    let errorMessage = 'Failed to load webhooks';
-                    if (error instanceof Error) {
-                        errorMessage += `: ${error.message}`;
-                        // Check for common issues
-                        if (error.message.includes('HTTP 401') || error.message.includes('Unauthorized')) {
-                            errorMessage = 'Authentication failed. Please check your API token in the credentials.';
-                        }
-                        else if (error.message.includes('HTTP 404')) {
-                            errorMessage = 'Webhook endpoint not found. Please check the API base URL in credentials.';
-                        }
-                        else if (error.message.includes('HTTP 403')) {
-                            errorMessage = 'Access forbidden. Your API token may not have permission to access webhooks.';
-                        }
-                        else if (error.message.includes('Failed to fetch') || error.message.includes('network')) {
-                            errorMessage = 'Network error. Please check the API base URL and ensure the Cribops API is accessible.';
-                        }
-                        else if (error.message.includes('HTTP 400')) {
-                            errorMessage = 'Bad request. Please check that the API endpoint is correct and your API token has the necessary permissions.';
-                        }
-                    }
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), errorMessage);
-                }
-            },
-        },
-    };
     webhookMethods = {
         default: {
             async checkExists() {
-                // Always return false to create webhook registration
-                // The actual webhook already exists in Cribops backend
+                // Always return false to ensure webhook is registered
                 return false;
             },
             async create() {
                 const webhookUrl = this.getNodeWebhookUrl('default');
-                const webhookId = this.getNodeParameter('webhookId');
+                const webhookPath = this.getNodeParameter('webhookPath');
+                const options = this.getNodeParameter('options');
                 const credentials = await this.getCredentials('cribopsApi');
                 const workflowId = this.getWorkflow().id;
                 const workflowName = this.getWorkflow().name;
+                if (!webhookPath) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Webhook path is required');
+                }
                 const cribopsHttp = new CribopsHttp_1.CribopsHttp({
                     baseUrl: credentials.baseUrl,
                     apiToken: credentials.apiToken,
                 });
                 try {
-                    // Link this workflow to the webhook entity
-                    const body = {
-                        workflow_id: workflowId,
-                        webhook_url: webhookUrl,
+                    // Register this N8N endpoint with Cribops so it knows where to send webhooks
+                    const registrationData = {
+                        webhook_path: webhookPath,
+                        n8n_webhook_url: webhookUrl,
                         test_webhook_url: webhookUrl.replace('/webhook/', '/webhook-test/'),
+                        workflow_id: workflowId,
                         workflow_name: workflowName || 'Unnamed Workflow',
+                        report_performance: options.reportPerformance !== false,
+                        report_errors: options.reportErrors !== false,
+                        signature_secret: options.signatureSecret ? String(options.signatureSecret) : null,
                     };
-                    // Link the n8n workflow to the webhook entity
-                    await cribopsHttp.request('POST', `/api/v1/webhooks/${webhookId}/link`, body);
+                    await cribopsHttp.registerN8NEndpoint(registrationData);
                     // Store webhook data for later use
                     const webhookData = this.getWorkflowStaticData('node');
-                    webhookData.webhookId = webhookId;
+                    webhookData.webhookPath = webhookPath;
                     webhookData.webhookUrl = webhookUrl;
                     return true;
                 }
                 catch (error) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to link webhook: ${error instanceof Error ? error.message : String(error)}`);
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to register N8N endpoint with Cribops: ${error instanceof Error ? error.message : String(error)}`);
                 }
             },
             async delete() {
                 const webhookData = this.getWorkflowStaticData('node');
                 const credentials = await this.getCredentials('cribopsApi');
-                if (!webhookData.webhookId) {
+                if (!webhookData.webhookPath) {
                     return true;
                 }
                 const cribopsHttp = new CribopsHttp_1.CribopsHttp({
@@ -195,15 +156,15 @@ class CribopsTrigger {
                     apiToken: credentials.apiToken,
                 });
                 try {
-                    // Unlink the workflow from the webhook entity
-                    await cribopsHttp.request('DELETE', `/api/v1/webhooks/${webhookData.webhookId}/link`);
-                    delete webhookData.webhookId;
+                    // Unregister the N8N endpoint
+                    await cribopsHttp.unregisterN8NEndpoint(webhookData.webhookPath);
+                    delete webhookData.webhookPath;
                     delete webhookData.webhookUrl;
                     return true;
                 }
                 catch (error) {
                     // Log error but don't fail
-                    console.error('Failed to unlink webhook:', error);
+                    console.error('Failed to unregister N8N endpoint:', error);
                     return true;
                 }
             },
@@ -212,68 +173,70 @@ class CribopsTrigger {
     async webhook() {
         const body = this.getBodyData();
         const headers = this.getHeaderData();
-        const eventTypes = this.getNodeParameter('eventTypes', []);
-        const additionalFields = this.getNodeParameter('additionalFields', {});
-        const webhookId = this.getNodeParameter('webhookId');
-        // Validate secret token if provided
-        if (additionalFields.secretToken) {
-            // Check for signature in headers (could be HMAC signature or bearer token)
-            const signature = headers['x-cribops-signature'] || headers['x-webhook-signature'];
-            const authHeader = headers['authorization'];
-            // You can implement HMAC signature validation here if needed
-            // For now, simple token comparison
-            if (additionalFields.secretToken !== signature && `Bearer ${additionalFields.secretToken}` !== authHeader) {
+        const options = this.getNodeParameter('options');
+        const webhookPath = this.getNodeParameter('webhookPath');
+        const credentials = await this.getCredentials('cribopsApi');
+        const startTime = Date.now();
+        // Validate signature if enabled (Cribops signs webhooks it sends)
+        if (options.validateSignature) {
+            const signature = headers['x-cribops-signature'];
+            const secret = options.signatureSecret;
+            if (!signature) {
                 return {
                     webhookResponse: {
                         status: 401,
-                        body: { error: 'Unauthorized' },
+                        body: { error: 'Missing Cribops signature' },
                     },
                 };
             }
+            // TODO: Implement HMAC validation with shared secret
         }
-        // Filter by event type if specified
-        const eventType = body.event_type || body.type || body.eventType;
-        if (eventTypes.length > 0 && eventType && !eventTypes.includes(eventType)) {
-            return {
-                webhookResponse: {
-                    status: 200,
-                    body: { received: true, filtered: true },
-                },
+        // Extract Cribops metadata from the webhook
+        const cribopsMetadata = {
+            webhook_id: body.webhook_id || headers['x-cribops-webhook-id'],
+            queue_name: body.queue_name || headers['x-cribops-queue'],
+            original_source: body.original_source || headers['x-cribops-source'],
+            received_at: body.received_at || headers['x-cribops-received-at'],
+            attempt_number: body.attempt_number || headers['x-cribops-attempt'] || 1,
+        };
+        // Prepare webhook data
+        const webhookData = {
+            // The actual webhook payload
+            payload: body.payload || body,
+            // Processing metadata
+            processed_at: new Date().toISOString(),
+            webhook_path: webhookPath,
+        };
+        // Include Cribops metadata if requested
+        if (options.includeCribopsMetadata !== false) {
+            webhookData.cribops = cribopsMetadata;
+        }
+        // Include original headers if requested
+        if (options.includeHeaders) {
+            webhookData.original_headers = body.original_headers || headers;
+        }
+        // Track processing time for performance reporting
+        const processingTime = Date.now() - startTime;
+        // If performance reporting is enabled, we'll report after workflow completes
+        if (options.reportPerformance !== false && cribopsMetadata.webhook_id) {
+            // Store for later reporting
+            const staticData = this.getWorkflowStaticData('node');
+            staticData.performanceTracking = {
+                webhook_id: cribopsMetadata.webhook_id,
+                start_time: startTime,
+                receive_time: processingTime,
             };
         }
-        // Prepare output data with all relevant fields
-        const outputData = {
-            // Core webhook data
-            webhook_id: webhookId,
-            event_type: eventType,
-            // Message content
-            message: body.message || body.content || body.text,
-            // Conversation/thread tracking
-            conversation_id: body.conversation_id || body.conversationId || body.thread_id || body.threadId,
-            // User/agent identification
-            user_id: body.user_id || body.userId || body.from_user || body.fromUser,
-            agent_id: body.agent_id || body.agentId || body.to_agent || body.toAgent,
-            // Response handling
-            response_webhook: body.response_webhook || body.responseWebhook || body.callback_url || body.callbackUrl,
-            // Metadata
-            metadata: body.metadata || {},
-            // File attachments if any
-            attachments: body.attachments || body.files || [],
-            // Timestamp
-            timestamp: body.timestamp || body.created_at || body.createdAt || new Date().toISOString(),
-            // Include any other fields from the webhook
-            ...body,
-        };
-        // Include headers if requested
-        const workflowData = additionalFields.includeHeaders
-            ? { json: outputData, headers }
-            : { json: outputData };
         // Return the data to the workflow
         return {
-            workflowData: [[workflowData]],
+            workflowData: [[{ json: webhookData }]],
             webhookResponse: {
                 status: 200,
-                body: { received: true },
+                body: {
+                    received: true,
+                    webhook_id: cribopsMetadata.webhook_id,
+                    processing_time_ms: processingTime,
+                },
             },
         };
     }

package/dist/nodes/HiveAccelerator/HiveAccelerator.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class HiveAccelerator implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}