n8n-nodes-cribops 0.1.17 → 0.1.20

package/dist/credentials/CribopsApi.credentials.js

@@ -25,6 +25,13 @@ class CribopsApi {
             required: true,
             description: 'Base URL of the Cribops API',
         },
+        {
+            displayName: 'Organization ID',
+            name: 'organizationId',
+            type: 'string',
+            default: '',
+            description: 'Organization ID (optional - if not provided, will use the default organization for the API token)',
+        },
     ];
     authenticate = {
         type: 'generic',

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

@@ -1,9 +1,9 @@
-import { INodeType, INodeTypeDescription, ITriggerFunctions, ITriggerResponse, IWebhookFunctions, IWebhookResponseData, IHookFunctions, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+import { INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData, IHookFunctions, ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
 export declare class CribopsTrigger implements INodeType {
     description: INodeTypeDescription;
     methods: {
         loadOptions: {
-            getAgents(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getWebhooks(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
         };
     };
     webhookMethods: {
@@ -13,6 +13,5 @@ export declare class CribopsTrigger implements INodeType {
             delete(this: IHookFunctions): Promise<boolean>;
         };
     };
-    trigger(this: ITriggerFunctions): Promise<ITriggerResponse>;
     webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
 }

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

@@ -10,7 +10,7 @@ class CribopsTrigger {
         icon: 'file:cribopstrigger.svg',
         group: ['trigger'],
         version: 1,
-        description: 'Triggers when receiving messages from Cribops agents',
+        description: 'Triggers when receiving messages via Cribops webhook',
         defaults: {
             name: 'Cribops Trigger',
         },
@@ -27,92 +27,21 @@ class CribopsTrigger {
                 name: 'default',
                 httpMethod: 'POST',
                 responseMode: 'onReceived',
-                // Dynamic path to trigger UUID generation
-                path: '={{$parameter["agentId"]}}',
-                isFullPath: true,
+                path: '={{$parameter["webhookId"]}}',
+                isFullPath: false,
             },
         ],
-        polling: true,
         properties: [
             {
-                displayName: 'Trigger Mode',
-                name: 'triggerMode',
+                displayName: 'Webhook Name or ID',
+                name: 'webhookId',
                 type: 'options',
-                options: [
-                    {
-                        name: 'Polling',
-                        value: 'polling',
-                        description: 'Poll the queue for messages at regular intervals',
-                    },
-                    {
-                        name: 'Webhook',
-                        value: 'webhook',
-                        description: 'Receive messages via webhook',
-                    },
-                ],
-                default: 'polling',
-                description: 'How to receive messages from Cribops',
-            },
-            {
-                displayName: 'Tenant ID',
-                name: 'tenantId',
-                type: 'string',
                 required: true,
-                default: '',
-                description: 'The tenant ID for your Cribops organization',
-            },
-            {
-                displayName: 'Agent Name or ID',
-                name: 'agentId',
-                type: 'options',
-                required: true,
-                displayOptions: {
-                    show: {
-                        triggerMode: ['webhook'],
-                    },
-                },
                 typeOptions: {
-                    loadOptionsMethod: 'getAgents',
+                    loadOptionsMethod: 'getWebhooks',
                 },
                 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: 'Queue Name',
-                name: 'queueName',
-                type: 'string',
-                displayOptions: {
-                    show: {
-                        triggerMode: ['polling'],
-                    },
-                },
-                default: '',
-                placeholder: 'e.g., stripe_events',
-                description: 'Specific queue to poll (optional). Leave empty to poll all queues.',
-            },
-            {
-                displayName: 'Poll Interval',
-                name: 'pollInterval',
-                type: 'number',
-                displayOptions: {
-                    show: {
-                        triggerMode: ['polling'],
-                    },
-                },
-                default: 30,
-                description: 'How often to poll for messages in seconds',
-            },
-            {
-                displayName: 'Batch Size',
-                name: 'batchSize',
-                type: 'number',
-                displayOptions: {
-                    show: {
-                        triggerMode: ['polling'],
-                    },
-                },
-                default: 10,
-                description: 'Number of messages to retrieve per poll (max 100)',
+                description: 'Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>',
             },
             {
                 displayName: 'Event Types',
@@ -134,8 +63,13 @@ class CribopsTrigger {
                         value: 'file_attachment',
                         description: 'File attachments',
                     },
+                    {
+                        name: 'System Event',
+                        value: 'system_event',
+                        description: 'System events and notifications',
+                    },
                 ],
-                default: ['user_message'],
+                default: ['user_message', 'agent_response'],
                 description: 'Types of events to trigger on',
             },
             {
@@ -153,7 +87,14 @@ class CribopsTrigger {
                             password: true,
                         },
                         default: '',
-                        description: 'Secret token for webhook authentication',
+                        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',
                     },
                 ],
             },
@@ -161,22 +102,28 @@ class CribopsTrigger {
     };
     methods = {
         loadOptions: {
-            async getAgents() {
+            async getWebhooks() {
                 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}`,
+                    // Get organization ID from credentials if provided
+                    const organizationId = credentials.organizationId;
+                    const webhooks = await cribopsHttp.getWebhooks(organizationId);
+                    // 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) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load agents: ${error instanceof Error ? error.message : String(error)}`);
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to load webhooks: ${error instanceof Error ? error.message : String(error)}`);
                 }
             },
         },
@@ -184,52 +131,38 @@ class CribopsTrigger {
     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;
-                }
+                // Always return false to create webhook registration
+                // The actual webhook already exists in Cribops backend
+                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 webhookId = this.getNodeParameter('webhookId');
                 const credentials = await this.getCredentials('cribopsApi');
+                const workflowId = this.getWorkflow().id;
+                const workflowName = this.getWorkflow().name;
                 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
+                    // Link this workflow to the webhook entity
                     const body = {
-                        url: webhookUrl,
-                        agent_id: agentId,
-                        event_types: eventTypes,
-                        secret: additionalFields.secretToken || undefined,
+                        workflow_id: workflowId,
+                        webhook_url: webhookUrl,
+                        test_webhook_url: webhookUrl.replace('/webhook/', '/webhook-test/'),
+                        workflow_name: workflowName || 'Unnamed Workflow',
                     };
-                    // TODO: Make actual API call to register webhook
-                    // await cribopsHttp.registerWebhook(agentId, body);
+                    // Link the n8n workflow to the webhook entity
+                    await cribopsHttp.request('POST', `/api/v1/webhooks/${webhookId}/link`, body);
                     // Store webhook data for later use
                     const webhookData = this.getWorkflowStaticData('node');
-                    webhookData.webhookId = `webhook_${agentId}_${Date.now()}`;
-                    webhookData.agentId = agentId;
+                    webhookData.webhookId = webhookId;
+                    webhookData.webhookUrl = webhookUrl;
                     return true;
                 }
                 catch (error) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to register webhook: ${error instanceof Error ? error.message : String(error)}`);
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to link webhook: ${error instanceof Error ? error.message : String(error)}`);
                 }
             },
             async delete() {
@@ -243,118 +176,34 @@ class CribopsTrigger {
                     apiToken: credentials.apiToken,
                 });
                 try {
-                    // Unregister webhook from Cribops
-                    // TODO: Make actual API call to unregister webhook
-                    // await cribopsHttp.deleteWebhook(webhookData.agentId, webhookData.webhookId);
+                    // Unlink the workflow from the webhook entity
+                    await cribopsHttp.request('DELETE', `/api/v1/webhooks/${webhookData.webhookId}/link`);
                     delete webhookData.webhookId;
-                    delete webhookData.agentId;
+                    delete webhookData.webhookUrl;
                     return true;
                 }
                 catch (error) {
-                    return false;
+                    // Log error but don't fail
+                    console.error('Failed to unlink webhook:', error);
+                    return true;
                 }
             },
         },
     };
-    async trigger() {
-        const triggerMode = this.getNodeParameter('triggerMode');
-        if (triggerMode === 'webhook') {
-            // Webhook mode - minimal implementation as 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 in webhook mode. Please activate the workflow.');
-                },
-            };
-        }
-        // Polling mode
-        const credentials = await this.getCredentials('cribopsApi');
-        const tenantId = this.getNodeParameter('tenantId');
-        const pollInterval = this.getNodeParameter('pollInterval', 30);
-        const batchSize = this.getNodeParameter('batchSize', 10);
-        const queueName = this.getNodeParameter('queueName', '') || undefined;
-        const cribopsHttp = new CribopsHttp_1.CribopsHttp({
-            baseUrl: credentials.baseUrl,
-            apiToken: credentials.apiToken,
-        });
-        let intervalId;
-        const poll = async () => {
-            try {
-                const messages = await cribopsHttp.pollQueue(tenantId, batchSize, queueName);
-                if (messages.length > 0) {
-                    const messageIds = messages.map(msg => msg.id);
-                    // Process each message
-                    for (const message of messages) {
-                        // Parse the webhook data if it's JSON
-                        let parsedData = message.data.data;
-                        try {
-                            parsedData = JSON.parse(message.data.data);
-                        }
-                        catch (e) {
-                            // Keep as string if not valid JSON
-                        }
-                        // Emit the message
-                        this.emit([
-                            [
-                                {
-                                    json: {
-                                        id: message.id,
-                                        correlation_id: message.correlation_id,
-                                        queue_name: message.queue_name,
-                                        data: parsedData,
-                                        headers: message.data.headers,
-                                        params: message.data.params,
-                                        inserted_at: message.inserted_at,
-                                        // Extract useful fields from headers
-                                        tenant_id: message.data.headers['x-cribops-tenant-id'] || tenantId,
-                                        path: message.data.headers['x-cribops-path'],
-                                    },
-                                },
-                            ],
-                        ]);
-                    }
-                    // Acknowledge messages after processing
-                    try {
-                        await cribopsHttp.acknowledgeMessages(tenantId, messageIds);
-                    }
-                    catch (ackError) {
-                        console.error('Failed to acknowledge messages:', ackError);
-                    }
-                }
-            }
-            catch (error) {
-                console.error('Polling error:', error);
-                // Don't throw - continue polling
-            }
-        };
-        // Start polling
-        poll(); // Initial poll
-        intervalId = setInterval(poll, pollInterval * 1000);
-        // Manual trigger function for testing
-        const manualTriggerFunction = async () => {
-            await poll();
-        };
-        // Cleanup function
-        const closeFunction = async () => {
-            if (intervalId) {
-                clearInterval(intervalId);
-            }
-        };
-        return {
-            closeFunction,
-            manualTriggerFunction,
-        };
-    }
     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');
+        const webhookId = this.getNodeParameter('webhookId');
         // Validate secret token if provided
         if (additionalFields.secretToken) {
-            const receivedToken = headers['x-cribops-signature'] || headers['authorization'];
-            if (receivedToken !== 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) {
                 return {
                     webhookResponse: {
                         status: 401,
@@ -363,8 +212,9 @@ class CribopsTrigger {
                 };
             }
         }
-        // Filter by event type
-        if (eventTypes.length > 0 && body.type && !eventTypes.includes(body.type)) {
+        // 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,
@@ -372,27 +222,40 @@ class CribopsTrigger {
                 },
             };
         }
-        // Enrich the output with agent_id and other useful metadata
+        // 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,
-            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));
+        // Include headers if requested
+        const workflowData = additionalFields.includeHeaders
+            ? { json: outputData, headers }
+            : { json: outputData };
         // Return the data to the workflow
         return {
-            workflowData: [
-                [
-                    {
-                        json: outputData,
-                        headers,
-                    },
-                ],
-            ],
+            workflowData: [[workflowData]],
+            webhookResponse: {
+                status: 200,
+                body: { received: true },
+            },
         };
     }
 }

package/dist/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-cribops",
-  "version": "0.1.17",
+  "version": "0.1.20",
   "description": "n8n community node for Cribops AI platform integration",
   "keywords": [
     "n8n-community-node-package"

package/dist/utils/CribopsHttp.d.ts

@@ -1,4 +1,4 @@
-import { IDataObject } from 'n8n-workflow';
+import { IDataObject, IHttpRequestMethods, IHttpRequestOptions } from 'n8n-workflow';
 export interface CribopsHttpConfig {
     baseUrl: string;
     apiToken: string;
@@ -37,6 +37,18 @@ export interface CribopsQueueMessage {
     };
     inserted_at: string;
 }
+export interface CribopsWebhookEntity {
+    id: string;
+    name: string;
+    description?: string;
+    type: 'N8N' | 'GHL_API' | 'GENERIC';
+    status: 'active' | 'inactive';
+    linked_workflow_id?: string;
+    linked_workflow_name?: string;
+    organization_id: string;
+    created_at: string;
+    updated_at: string;
+}
 export declare class CribopsHttp {
     private config;
     constructor(config: CribopsHttpConfig);
@@ -57,4 +69,13 @@ export declare class CribopsHttp {
         status: string;
         updated_count: number;
     }>;
+    getWebhooks(organizationId?: string): Promise<CribopsWebhookEntity[]>;
+    linkWebhook(webhookId: string, linkData: {
+        workflow_id: string;
+        webhook_url: string;
+        test_webhook_url: string;
+        workflow_name: string;
+    }): Promise<any>;
+    unlinkWebhook(webhookId: string): Promise<any>;
+    request<T = any>(method: IHttpRequestMethods, endpoint: string, data?: IDataObject, options?: Partial<IHttpRequestOptions>): Promise<T>;
 }

package/dist/utils/CribopsHttp.js

@@ -10,7 +10,21 @@ class CribopsHttp {
         };
     }
     async makeRequest(method, endpoint, data, options) {
-        const url = `${this.config.baseUrl}${endpoint}`;
+        let url = `${this.config.baseUrl}${endpoint}`;
+        // Handle query parameters
+        if (method === 'GET' && data?.params) {
+            const params = new URLSearchParams();
+            Object.entries(data.params).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    params.append(key, String(value));
+                }
+            });
+            const queryString = params.toString();
+            if (queryString) {
+                url += `?${queryString}`;
+            }
+            delete data.params;
+        }
         const requestHeaders = {
             'Authorization': `Bearer ${this.config.apiToken}`,
             'Content-Type': 'application/json',
@@ -25,7 +39,7 @@ class CribopsHttp {
             const response = await fetch(url, {
                 method,
                 headers: requestHeaders,
-                body: data ? JSON.stringify(data) : undefined,
+                body: (method !== 'GET' && data) ? JSON.stringify(data) : undefined,
             });
             if (!response.ok) {
                 const errorText = await response.text();
@@ -144,5 +158,36 @@ class CribopsHttp {
             throw new Error(`Failed to mark messages as failed for tenant ${tenantId}: ${error}`);
         }
     }
+    // Webhook-specific methods
+    async getWebhooks(organizationId) {
+        try {
+            const params = organizationId ? { params: { organization_id: organizationId } } : undefined;
+            const response = await this.makeRequest('GET', '/api/v1/webhooks', params);
+            return response.data || [];
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch webhooks: ${error}`);
+        }
+    }
+    async linkWebhook(webhookId, linkData) {
+        try {
+            return await this.makeRequest('POST', `/api/v1/webhooks/${webhookId}/link`, linkData);
+        }
+        catch (error) {
+            throw new Error(`Failed to link webhook: ${error}`);
+        }
+    }
+    async unlinkWebhook(webhookId) {
+        try {
+            return await this.makeRequest('DELETE', `/api/v1/webhooks/${webhookId}/link`);
+        }
+        catch (error) {
+            throw new Error(`Failed to unlink webhook: ${error}`);
+        }
+    }
+    // Generic request method for custom API calls
+    async request(method, endpoint, data, options) {
+        return this.makeRequest(method, endpoint, data, options);
+    }
 }
 exports.CribopsHttp = CribopsHttp;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-cribops",
-  "version": "0.1.17",
+  "version": "0.1.20",
   "description": "n8n community node for Cribops AI platform integration",
   "keywords": [
     "n8n-community-node-package"