n8n-nodes-cribops 0.1.16 → 0.1.18

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.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,21 +27,21 @@ class CribopsTrigger {
                 name: 'default',
                 httpMethod: 'POST',
                 responseMode: 'onReceived',
-                // Dynamic path to trigger UUID generation
-                path: '={{$parameter["agentId"]}}',
+                path: '={{$parameter["webhookId"]}}',
+                isFullPath: false,
             },
         ],
         properties: [
             {
-                displayName: 'Agent Name or ID',
-                name: 'agentId',
+                displayName: 'Webhook Name or ID',
+                name: 'webhookId',
                 type: 'options',
                 required: true,
                 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>.',
+                description: 'The Cribops webhook to use. Choose from the list, or specify an ID using an <a href="https://docs.n8n.io/code/expressions/">expression</a>.',
             },
             {
                 displayName: 'Event Types',
@@ -63,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',
             },
             {
@@ -82,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',
                     },
                 ],
             },
@@ -90,22 +102,25 @@ 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}`,
+                    // Call the API to get available webhooks
+                    // The API endpoint would be something like GET /api/v1/webhooks
+                    const response = await cribopsHttp.request('GET', '/api/v1/webhooks');
+                    const webhooks = response.data || [];
+                    return webhooks.map((webhook) => ({
+                        name: webhook.name || webhook.id,
+                        value: webhook.id,
+                        description: webhook.description || `Webhook ID: ${webhook.id}`,
                     }));
                 }
                 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)}`);
                 }
             },
         },
@@ -113,26 +128,13 @@ 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 webhookId = this.getNodeParameter('webhookId');
                 const eventTypes = this.getNodeParameter('eventTypes', []);
                 const additionalFields = this.getNodeParameter('additionalFields', {});
                 const credentials = await this.getCredentials('cribopsApi');
@@ -141,30 +143,29 @@ class CribopsTrigger {
                     apiToken: credentials.apiToken,
                 });
                 try {
-                    // Register webhook with Cribops
-                    // This is a placeholder - implement actual API call
+                    // Register this n8n webhook URL with the Cribops webhook
                     const body = {
-                        url: webhookUrl,
-                        agent_id: agentId,
+                        webhook_id: webhookId,
+                        target_url: webhookUrl,
                         event_types: eventTypes,
                         secret: additionalFields.secretToken || undefined,
                     };
-                    // TODO: Make actual API call to register webhook
-                    // await cribopsHttp.registerWebhook(agentId, body);
+                    // Register the n8n webhook URL with Cribops
+                    await cribopsHttp.request('POST', `/api/v1/webhooks/${webhookId}/targets`, 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.targetUrl = 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 register webhook target: ${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.webhookId || !webhookData.targetUrl) {
                     return true;
                 }
                 const cribopsHttp = new CribopsHttp_1.CribopsHttp({
@@ -172,38 +173,36 @@ 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);
+                    // Unregister the n8n webhook URL from Cribops
+                    await cribopsHttp.request('DELETE', `/api/v1/webhooks/${webhookData.webhookId}/targets`, {
+                        target_url: webhookData.targetUrl,
+                    });
                     delete webhookData.webhookId;
-                    delete webhookData.agentId;
+                    delete webhookData.targetUrl;
                     return true;
                 }
                 catch (error) {
-                    return false;
+                    // Log error but don't fail
+                    console.error('Failed to unregister webhook target:', error);
+                    return true;
                 }
             },
         },
     };
-    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');
+        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,
@@ -212,8 +211,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,
@@ -221,27 +221,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.16",
+  "version": "0.1.18",
   "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;
@@ -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,14 @@ 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;
+    }>;
+    request<T = any>(method: IHttpRequestMethods, endpoint: string, data?: IDataObject, options?: Partial<IHttpRequestOptions>): Promise<T>;
 }

package/dist/utils/CribopsHttp.js

@@ -112,5 +112,41 @@ 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}`);
+        }
+    }
+    // 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.16",
+  "version": "0.1.18",
   "description": "n8n community node for Cribops AI platform integration",
   "keywords": [
     "n8n-community-node-package"