n8n-nodes-cribops 0.1.16 → 0.1.17

package/dist/credentials/CribopsApi.credentials.js

@@ -21,7 +21,7 @@ class CribopsApi {
             displayName: 'Base URL',
             name: 'baseUrl',
             type: 'string',
-            default: 'https://api.cribops.com',
+            default: 'https://cribops.com',
             required: true,
             description: 'Base URL of the Cribops API',
         },

package/dist/nodes/Cribops/Cribops.node.js

@@ -48,6 +48,12 @@ class Cribops {
                         description: 'List all available agents',
                         action: 'List all available agents',
                     },
+                    {
+                        name: 'Poll Queue',
+                        value: 'pollQueue',
+                        description: 'Poll messages from the queue',
+                        action: 'Poll messages from the queue',
+                    },
                     {
                         name: 'Reply to Conversation',
                         value: 'replyToConversation',
@@ -149,6 +155,45 @@ class Cribops {
                 },
                 description: 'Whether to show typing indicator (true) or stop typing (false)',
             },
+            {
+                displayName: 'Tenant ID',
+                name: 'tenantId',
+                type: 'string',
+                required: true,
+                default: '',
+                placeholder: 'my-tenant',
+                displayOptions: {
+                    show: {
+                        operation: ['pollQueue'],
+                    },
+                },
+                description: 'The tenant ID for your Cribops organization',
+            },
+            {
+                displayName: 'Batch Size',
+                name: 'batchSize',
+                type: 'number',
+                default: 10,
+                displayOptions: {
+                    show: {
+                        operation: ['pollQueue'],
+                    },
+                },
+                description: 'Number of messages to retrieve (max 100)',
+            },
+            {
+                displayName: 'Queue Name',
+                name: 'queueName',
+                type: 'string',
+                default: '',
+                placeholder: 'e.g., stripe_events',
+                displayOptions: {
+                    show: {
+                        operation: ['pollQueue'],
+                    },
+                },
+                description: 'Specific queue to poll (optional). Leave empty to poll all queues.',
+            },
             {
                 displayName: 'Message',
                 name: 'message',
@@ -342,6 +387,9 @@ class Cribops {
                     case 'listAgents':
                         responseData = await listAgents(this, cribopsHttp, i);
                         break;
+                    case 'pollQueue':
+                        responseData = await pollQueue(this, cribopsHttp, i);
+                        break;
                     default:
                         throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Unknown operation: ${operation}`, { itemIndex: i });
                 }
@@ -536,6 +584,46 @@ async function listAgents(executeFunctions, cribopsHttp, itemIndex) {
     const agents = await cribopsHttp.getAgents();
     return { agents, count: agents.length };
 }
+async function pollQueue(executeFunctions, cribopsHttp, itemIndex) {
+    const tenantId = executeFunctions.getNodeParameter('tenantId', itemIndex);
+    const batchSize = executeFunctions.getNodeParameter('batchSize', itemIndex, 10);
+    const queueName = executeFunctions.getNodeParameter('queueName', itemIndex, '') || undefined;
+    const messages = await cribopsHttp.pollQueue(tenantId, batchSize, queueName);
+    // Process each message to parse the data if it's JSON
+    const processedMessages = messages.map(message => {
+        let parsedData = message.data.data;
+        try {
+            parsedData = JSON.parse(message.data.data);
+        }
+        catch (e) {
+            // Keep as string if not valid JSON
+        }
+        return {
+            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'],
+        };
+    });
+    // Auto-acknowledge messages after processing
+    if (messages.length > 0) {
+        const messageIds = messages.map(msg => msg.id);
+        try {
+            await cribopsHttp.acknowledgeMessages(tenantId, messageIds);
+        }
+        catch (ackError) {
+            // Log error but don't fail the operation
+            console.error('Failed to acknowledge messages:', ackError);
+        }
+    }
+    return { messages: processedMessages, count: processedMessages.length };
+}
 async function sendTypingIndicator(executeFunctions, cribopsHttp, itemIndex) {
     const agentId = executeFunctions.getNodeParameter('agentId', itemIndex, '', { extractValue: true });
     const conversationId = executeFunctions.getNodeParameter('conversationId', itemIndex);

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

@@ -29,20 +29,91 @@ class CribopsTrigger {
                 responseMode: 'onReceived',
                 // Dynamic path to trigger UUID generation
                 path: '={{$parameter["agentId"]}}',
+                isFullPath: true,
             },
         ],
+        polling: true,
         properties: [
+            {
+                displayName: 'Trigger Mode',
+                name: 'triggerMode',
+                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',
                 },
                 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)',
+            },
             {
                 displayName: 'Event Types',
                 name: 'eventTypes',
@@ -186,12 +257,92 @@ class CribopsTrigger {
         },
     };
     async trigger() {
-        // Minimal implementation - webhooks are handled by webhook() method
+        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: async () => { },
-            manualTriggerFunction: async () => {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'This node only works with webhooks. Please activate the workflow.');
-            },
+            closeFunction,
+            manualTriggerFunction,
         };
     }
     async webhook() {

package/dist/package.json

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

package/dist/utils/CribopsHttp.d.ts

@@ -26,6 +26,17 @@ export interface CribopsWebhookMessage {
     fileName?: string;
     fileType?: string;
 }
+export interface CribopsQueueMessage {
+    id: number;
+    correlation_id: string;
+    queue_name: string;
+    data: {
+        data: string;
+        params: IDataObject;
+        headers: IDataObject;
+    };
+    inserted_at: string;
+}
 export declare class CribopsHttp {
     private config;
     constructor(config: CribopsHttpConfig);
@@ -37,4 +48,13 @@ export declare class CribopsHttp {
     validateWebhook(payload: any, signature: string): Promise<boolean>;
     testConnection(): Promise<boolean>;
     sendTypingIndicator(agentId: string, conversationId: string, typing: boolean): Promise<any>;
+    pollQueue(tenantId: string, limit?: number, queueName?: string): Promise<CribopsQueueMessage[]>;
+    acknowledgeMessages(tenantId: string, messageIds: number[]): Promise<{
+        status: string;
+        deleted_count: number;
+    }>;
+    failMessages(tenantId: string, messageIds: number[], errorMessage: string): Promise<{
+        status: string;
+        updated_count: number;
+    }>;
 }

package/dist/utils/CribopsHttp.js

@@ -112,5 +112,37 @@ class CribopsHttp {
             throw new Error(`Failed to send typing indicator for agent ${agentId}: ${error}`);
         }
     }
+    async pollQueue(tenantId, limit = 10, queueName) {
+        try {
+            const params = { limit };
+            if (queueName) {
+                params.queue_name = queueName;
+            }
+            const url = `/api/queue/${tenantId}/poll?${new URLSearchParams(params).toString()}`;
+            const response = await this.makeRequest('GET', url);
+            return response;
+        }
+        catch (error) {
+            throw new Error(`Failed to poll queue for tenant ${tenantId}: ${error}`);
+        }
+    }
+    async acknowledgeMessages(tenantId, messageIds) {
+        try {
+            const response = await this.makeRequest('POST', `/api/queue/${tenantId}/acknowledge`, { message_ids: messageIds });
+            return response;
+        }
+        catch (error) {
+            throw new Error(`Failed to acknowledge messages for tenant ${tenantId}: ${error}`);
+        }
+    }
+    async failMessages(tenantId, messageIds, errorMessage) {
+        try {
+            const response = await this.makeRequest('POST', `/api/queue/${tenantId}/fail`, { message_ids: messageIds, error_message: errorMessage });
+            return response;
+        }
+        catch (error) {
+            throw new Error(`Failed to mark messages as failed for tenant ${tenantId}: ${error}`);
+        }
+    }
 }
 exports.CribopsHttp = CribopsHttp;

package/package.json

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