n8n-nodes-cribops 0.1.20 → 0.2.0

package/dist/utils/CribopsHttp.d.ts

@@ -4,78 +4,212 @@ export interface CribopsHttpConfig {
     apiToken: string;
     timeout?: number;
 }
-export interface CribopsAgent {
+export interface CribopsWebhookDelivery {
     id: string;
-    name: string;
-    description?: string;
-    status: 'active' | 'inactive';
-    tenantId: string;
-    organizationId: string;
-    metadata?: IDataObject;
+    webhook_id: string;
+    destination_url: string;
+    status: 'pending' | 'delivered' | 'failed' | 'retrying';
+    attempts: number;
+    max_attempts: number;
+    last_attempt_at?: string;
+    next_retry_at?: string;
+    response_status?: number;
+    response_body?: string;
+    error_message?: string;
+    created_at: string;
+    delivered_at?: string;
 }
-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 interface CribopsWebhookMetrics {
+    total_webhooks: number;
+    successful_deliveries: number;
+    failed_deliveries: number;
+    pending_deliveries: number;
+    average_delivery_time_ms: number;
+    success_rate: number;
+    destinations: {
+        url: string;
+        count: number;
+        success_rate: number;
+        average_response_time_ms: number;
+    }[];
 }
-export interface CribopsQueueMessage {
-    id: number;
-    correlation_id: string;
-    queue_name: string;
-    data: {
-        data: string;
-        params: IDataObject;
-        headers: IDataObject;
+export interface CribopsWebhookStore extends IDataObject {
+    webhook_id: string;
+    destination_url: string;
+    payload: IDataObject;
+    headers?: IDataObject;
+    priority: 'low' | 'normal' | 'high';
+    max_retries: number;
+    retry_delay: number;
+    rate_limit: number;
+    timeout: number;
+    authentication?: {
+        type: 'none' | 'bearer' | 'basic' | 'apikey';
+        value: string;
     };
-    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);
     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>;
-    pollQueue(tenantId: string, limit?: number, queueName?: string): Promise<CribopsQueueMessage[]>;
-    acknowledgeMessages(tenantId: string, messageIds: number[]): Promise<{
+    storeWebhook(data: CribopsWebhookStore): Promise<{
+        webhook_id: string;
         status: string;
-        deleted_count: number;
     }>;
-    failMessages(tenantId: string, messageIds: number[], errorMessage: string): Promise<{
+    getWebhookStatus(webhookId: string): Promise<CribopsWebhookDelivery>;
+    retryWebhook(webhookId: string): Promise<{
         status: string;
-        updated_count: number;
+        retry_scheduled: boolean;
+    }>;
+    listDeliveries(filters?: {
+        status?: string;
+        destination_url?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        deliveries: CribopsWebhookDelivery[];
+        total: number;
     }>;
-    getWebhooks(organizationId?: string): Promise<CribopsWebhookEntity[]>;
-    linkWebhook(webhookId: string, linkData: {
+    getMetrics(timeRange: string): Promise<CribopsWebhookMetrics>;
+    registerWebhookEndpoint(config: {
+        path: string;
         workflow_id: string;
+        workflow_name: string;
         webhook_url: string;
         test_webhook_url: string;
+        store_webhook: boolean;
+        acknowledge_immediately: boolean;
+        enable_deduplication?: boolean;
+        deduplication_window?: number;
+        enable_rate_limit?: boolean;
+        rate_limit?: number;
+        allowed_ips?: string[];
+        metadata?: IDataObject;
+    }): Promise<{
+        endpoint_id: string;
+        status: string;
+    }>;
+    unregisterWebhookEndpoint(path: string): Promise<{
+        status: string;
+    }>;
+    receiveWebhook(data: {
+        path: string;
+        headers?: IDataObject;
+        query?: IDataObject;
+        body: IDataObject;
+        metadata?: IDataObject;
+        source_ip?: string;
+    }): Promise<{
+        webhook_id: string;
+        status: string;
+    }>;
+    replayWebhook(webhookId: string, options?: {
+        destination_url?: string;
+        headers?: IDataObject;
+    }): Promise<{
+        status: string;
+        delivery_id: string;
+    }>;
+    testConnection(): Promise<boolean>;
+    reportError(data: {
+        webhook_id: string;
+        error: {
+            message: string;
+            type: string;
+            stack_trace?: string;
+            node_name?: string;
+            retry_recommended: boolean;
+            timestamp: string;
+            workflow_id?: string;
+            workflow_name?: string;
+        };
+    }): Promise<{
+        status: string;
+        error_id: string;
+    }>;
+    reportPerformance(data: {
+        webhook_id: string;
+        metrics: {
+            processing_time_ms: number;
+            memory_usage_mb?: number;
+            items_processed: number;
+            api_calls?: number;
+            success: boolean;
+            timestamp: string;
+            workflow_id?: string;
+            workflow_name?: string;
+        };
+    }): Promise<{
+        status: string;
+        metric_id: string;
+    }>;
+    sendCallback(data: {
+        webhook_id: string;
+        type: 'success' | 'failure' | 'partial';
+        data: IDataObject;
+        summary?: string;
+        timestamp: string;
+        workflow_id?: string;
+        workflow_name?: string;
+    }): Promise<{
+        status: string;
+        callback_id: string;
+    }>;
+    sendProgress(data: {
+        webhook_id: string;
+        progress: {
+            percentage: number;
+            message?: string;
+            items_completed?: number;
+            total_items?: number;
+            timestamp: string;
+        };
+    }): Promise<{
+        status: string;
+        progress_id: string;
+    }>;
+    analyzeWorkflow(data: {
+        workflow_id: string;
+        workflow_name: string;
+        metrics?: {
+            avg_execution_time_ms: number;
+            daily_executions: number;
+            failure_rate: number;
+            node_count: number;
+        };
+        workflow_definition?: {
+            nodes: any[];
+            connections: any;
+        };
+    }): Promise<{
+        status: string;
+        recommendations: Array<{
+            type: string;
+            priority: 'high' | 'medium' | 'low';
+            description: string;
+            estimated_improvement?: string;
+        }>;
+        optimization_potential: {
+            scalability_score: number;
+            parallelization_opportunities: number;
+            estimated_cost_reduction?: string;
+        };
+    }>;
+    registerN8NEndpoint(config: {
+        webhook_path: string;
+        n8n_webhook_url: string;
+        test_webhook_url?: string;
+        workflow_id?: string;
         workflow_name: string;
-    }): Promise<any>;
-    unlinkWebhook(webhookId: string): Promise<any>;
+        report_performance?: boolean;
+        report_errors?: boolean;
+        signature_secret?: string | null;
+    }): Promise<{
+        status: string;
+        endpoint_id: string;
+    }>;
+    unregisterN8NEndpoint(webhookPath: string): Promise<{
+        status: string;
+    }>;
     request<T = any>(method: IHttpRequestMethods, endpoint: string, data?: IDataObject, options?: Partial<IHttpRequestOptions>): Promise<T>;
 }

package/dist/utils/CribopsHttp.js

@@ -11,10 +11,10 @@ class CribopsHttp {
     }
     async makeRequest(method, endpoint, data, options) {
         let url = `${this.config.baseUrl}${endpoint}`;
-        // Handle query parameters
-        if (method === 'GET' && data?.params) {
+        // Handle query parameters for GET requests
+        if (method === 'GET' && data && Object.keys(data).length > 0) {
             const params = new URLSearchParams();
-            Object.entries(data.params).forEach(([key, value]) => {
+            Object.entries(data).forEach(([key, value]) => {
                 if (value !== undefined && value !== null) {
                     params.append(key, String(value));
                 }
@@ -23,7 +23,8 @@ class CribopsHttp {
             if (queryString) {
                 url += `?${queryString}`;
             }
-            delete data.params;
+            // Clear data for GET requests as params are in URL
+            data = undefined;
         }
         const requestHeaders = {
             'Authorization': `Bearer ${this.config.apiToken}`,
@@ -42,8 +43,17 @@ class CribopsHttp {
                 body: (method !== 'GET' && data) ? JSON.stringify(data) : undefined,
             });
             if (!response.ok) {
-                const errorText = await response.text();
-                throw new Error(`HTTP ${response.status}: ${errorText}`);
+                let errorText = await response.text();
+                let errorDetail = '';
+                // Try to parse error response as JSON
+                try {
+                    const errorJson = JSON.parse(errorText);
+                    errorDetail = errorJson.message || errorJson.error || errorText;
+                }
+                catch {
+                    errorDetail = errorText;
+                }
+                throw new Error(`HTTP ${response.status}: ${errorDetail}`);
             }
             const result = await response.json();
             return result;
@@ -52,137 +62,152 @@ class CribopsHttp {
             throw new Error(`Request failed: ${error}`);
         }
     }
-    async getAgents() {
+    // Webhook Store & Forward Operations
+    async storeWebhook(data) {
         try {
-            const response = await this.makeRequest('GET', '/api/v1/agents');
-            return response.agents || [];
+            return await this.makeRequest('POST', '/api/v1/webhooks/store', data);
         }
         catch (error) {
-            throw new Error(`Failed to fetch agents: ${error}`);
+            throw new Error(`Failed to store webhook: ${error}`);
         }
     }
-    async getAgent(agentId) {
+    async getWebhookStatus(webhookId) {
         try {
-            const response = await this.makeRequest('GET', `/api/v1/agents/${agentId}`);
-            return response.agent;
+            return await this.makeRequest('GET', `/api/v1/webhooks/${webhookId}/status`);
         }
         catch (error) {
-            throw new Error(`Failed to fetch agent ${agentId}: ${error}`);
+            throw new Error(`Failed to get webhook status: ${error}`);
         }
     }
-    async sendMessage(agentId, message) {
+    async retryWebhook(webhookId) {
         try {
-            const response = await this.makeRequest('POST', `/webhooks/agents/${agentId}/message`, message);
-            return response.message;
+            return await this.makeRequest('POST', `/api/v1/webhooks/${webhookId}/retry`);
         }
         catch (error) {
-            throw new Error(`Failed to send message to agent ${agentId}: ${error}`);
+            throw new Error(`Failed to retry webhook: ${error}`);
         }
     }
-    async downloadFile(fileUrl) {
+    async listDeliveries(filters) {
         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);
+            return await this.makeRequest('GET', '/api/v1/webhooks/deliveries', filters);
+        }
+        catch (error) {
+            throw new Error(`Failed to list webhook deliveries: ${error}`);
+        }
+    }
+    async getMetrics(timeRange) {
+        try {
+            return await this.makeRequest('GET', `/api/v1/webhooks/metrics`, { range: timeRange });
         }
         catch (error) {
-            throw new Error(`Failed to download file: ${error}`);
+            throw new Error(`Failed to get webhook metrics: ${error}`);
         }
     }
-    async validateWebhook(payload, signature) {
-        // Implement webhook signature validation if needed
-        // This would typically use HMAC verification
-        return true;
+    // Webhook Endpoint Registration (for trigger nodes)
+    async registerWebhookEndpoint(config) {
+        try {
+            return await this.makeRequest('POST', '/api/v1/webhook-endpoints/register', config);
+        }
+        catch (error) {
+            throw new Error(`Failed to register webhook endpoint: ${error}`);
+        }
     }
+    async unregisterWebhookEndpoint(path) {
+        try {
+            return await this.makeRequest('DELETE', `/api/v1/webhook-endpoints/${path}`);
+        }
+        catch (error) {
+            throw new Error(`Failed to unregister webhook endpoint: ${error}`);
+        }
+    }
+    // Webhook Reception (for storing incoming webhooks)
+    async receiveWebhook(data) {
+        try {
+            return await this.makeRequest('POST', '/api/v1/webhooks/receive', data);
+        }
+        catch (error) {
+            throw new Error(`Failed to receive webhook: ${error}`);
+        }
+    }
+    // Webhook Replay
+    async replayWebhook(webhookId, options) {
+        try {
+            return await this.makeRequest('POST', `/api/v1/webhooks/${webhookId}/replay`, options);
+        }
+        catch (error) {
+            throw new Error(`Failed to replay webhook: ${error}`);
+        }
+    }
+    // Test connection
     async testConnection() {
         try {
-            await this.getAgents();
+            await this.makeRequest('GET', '/api/v1/health');
             return true;
         }
         catch (error) {
             return false;
         }
     }
-    async sendTypingIndicator(agentId, conversationId, typing) {
+    // Error Reporting
+    async reportError(data) {
         try {
-            const response = await this.makeRequest('POST', `/api/agents/${agentId}/callback`, {
-                data: {
-                    typing: typing,
-                },
-                conversation_id: conversationId,
-                callback_type: 'typing',
-            });
-            return response;
+            return await this.makeRequest('POST', '/api/v1/webhooks/report-error', data);
         }
         catch (error) {
-            throw new Error(`Failed to send typing indicator for agent ${agentId}: ${error}`);
+            throw new Error(`Failed to report error: ${error}`);
         }
     }
-    async pollQueue(tenantId, limit = 10, queueName) {
+    // Performance Metrics Reporting
+    async reportPerformance(data) {
         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;
+            return await this.makeRequest('POST', '/api/v1/webhooks/report-performance', data);
         }
         catch (error) {
-            throw new Error(`Failed to poll queue for tenant ${tenantId}: ${error}`);
+            throw new Error(`Failed to report performance metrics: ${error}`);
         }
     }
-    async acknowledgeMessages(tenantId, messageIds) {
+    // Send Callback for Long-Running Workflows
+    async sendCallback(data) {
         try {
-            const response = await this.makeRequest('POST', `/api/queue/${tenantId}/acknowledge`, { message_ids: messageIds });
-            return response;
+            return await this.makeRequest('POST', '/api/v1/webhooks/callback', data);
         }
         catch (error) {
-            throw new Error(`Failed to acknowledge messages for tenant ${tenantId}: ${error}`);
+            throw new Error(`Failed to send callback: ${error}`);
         }
     }
-    async failMessages(tenantId, messageIds, errorMessage) {
+    // Send Progress Update
+    async sendProgress(data) {
         try {
-            const response = await this.makeRequest('POST', `/api/queue/${tenantId}/fail`, { message_ids: messageIds, error_message: errorMessage });
-            return response;
+            return await this.makeRequest('POST', '/api/v1/webhooks/progress', data);
         }
         catch (error) {
-            throw new Error(`Failed to mark messages as failed for tenant ${tenantId}: ${error}`);
+            throw new Error(`Failed to send progress update: ${error}`);
         }
     }
-    // Webhook-specific methods
-    async getWebhooks(organizationId) {
+    // Workflow Analysis
+    async analyzeWorkflow(data) {
         try {
-            const params = organizationId ? { params: { organization_id: organizationId } } : undefined;
-            const response = await this.makeRequest('GET', '/api/v1/webhooks', params);
-            return response.data || [];
+            return await this.makeRequest('POST', '/api/v1/workflows/analyze', data);
         }
         catch (error) {
-            throw new Error(`Failed to fetch webhooks: ${error}`);
+            throw new Error(`Failed to analyze workflow: ${error}`);
         }
     }
-    async linkWebhook(webhookId, linkData) {
+    // N8N Endpoint Registration (Updated for new architecture)
+    async registerN8NEndpoint(config) {
         try {
-            return await this.makeRequest('POST', `/api/v1/webhooks/${webhookId}/link`, linkData);
+            return await this.makeRequest('POST', '/api/v1/n8n-endpoints/register', config);
         }
         catch (error) {
-            throw new Error(`Failed to link webhook: ${error}`);
+            throw new Error(`Failed to register N8N endpoint: ${error}`);
         }
     }
-    async unlinkWebhook(webhookId) {
+    async unregisterN8NEndpoint(webhookPath) {
         try {
-            return await this.makeRequest('DELETE', `/api/v1/webhooks/${webhookId}/link`);
+            return await this.makeRequest('DELETE', `/api/v1/n8n-endpoints/${webhookPath}`);
         }
         catch (error) {
-            throw new Error(`Failed to unlink webhook: ${error}`);
+            throw new Error(`Failed to unregister N8N endpoint: ${error}`);
         }
     }
     // Generic request method for custom API calls

package/dist/utils/HiveClient.d.ts

@@ -0,0 +1,138 @@
+export interface HiveClientConfig {
+    host: string;
+    port: number;
+    password?: string;
+    tls?: boolean;
+}
+export interface HiveParallelHttpRequest {
+    url: string;
+    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    headers?: Record<string, string>;
+    body?: any;
+}
+export interface HiveParallelHttpResult {
+    url: string;
+    status: number | null;
+    body?: any;
+    error?: string;
+    time_ms: number;
+}
+export interface HiveCronConfig {
+    name: string;
+    expression: string;
+    webhook_url: string;
+    payload?: Record<string, any>;
+    timezone?: string;
+}
+export interface HiveCronInfo {
+    name: string;
+    expression: string;
+    webhook_url: string;
+    payload: Record<string, any>;
+    timezone: string;
+    enabled: boolean;
+    created_at: string;
+    next_run?: string;
+}
+export interface HiveFanoutResult {
+    endpoint: string;
+    status?: number;
+    success: boolean;
+    error?: string;
+}
+export interface HiveCircuitStatus {
+    service: string;
+    status: 'closed' | 'open' | 'half_open';
+    failure_count: number;
+    last_failure: string | null;
+    can_proceed: boolean;
+}
+export declare class HiveClient {
+    private redis;
+    private connected;
+    constructor(config: HiveClientConfig);
+    connect(): Promise<void>;
+    disconnect(): Promise<void>;
+    private execute;
+    ping(): Promise<{
+        pong: boolean;
+        timestamp: string;
+    }>;
+    info(): Promise<{
+        version: string;
+        accelerator: boolean;
+        oban_pro: boolean;
+        operations: string[];
+        dedup_stats: {
+            active_dedup_keys: number;
+            ttl_ms: number;
+        };
+    }>;
+    /**
+     * Execute multiple HTTP requests in parallel via Hive's Elixir Task.async_stream
+     */
+    parallelHttp(requests: HiveParallelHttpRequest[], options?: {
+        concurrency?: number;
+        timeout_ms?: number;
+    }): Promise<{
+        results: HiveParallelHttpResult[];
+        stats: {
+            total: number;
+            successful: number;
+            failed: number;
+            total_time_ms: number;
+        };
+    }>;
+    /**
+     * Schedule a dynamic cron job via Oban Pro
+     */
+    scheduleCron(config: HiveCronConfig): Promise<{
+        scheduled: boolean;
+        name: string;
+        expression: string;
+        timezone: string;
+        next_run: string | null;
+    }>;
+    /**
+     * Delete a dynamic cron job
+     */
+    deleteCron(name: string): Promise<{
+        deleted: boolean;
+        name: string;
+    }>;
+    /**
+     * List all dynamic cron jobs
+     */
+    listCrons(): Promise<{
+        crons: HiveCronInfo[];
+        count: number;
+    }>;
+    /**
+     * Fan-out a payload to multiple webhook endpoints in parallel
+     */
+    fanout(endpoints: string[], payload: Record<string, any>, options?: {
+        timeout_ms?: number;
+    }): Promise<{
+        results: HiveFanoutResult[];
+        stats: {
+            total: number;
+            successful: number;
+            failed: number;
+            total_time_ms: number;
+        };
+    }>;
+    /**
+     * Check if data is a duplicate (deduplication)
+     */
+    dedupCheck(data: Record<string, any>, options?: {
+        ttl_seconds?: number;
+    }): Promise<{
+        is_duplicate: boolean;
+        hash: string;
+        first_seen: string;
+    }>;
+    /**
+     * Check circuit breaker status and optionally record success/failure
+     */
+    circuitCheck(service: string, recordResult?: 'success' | 'failure'): Promise<HiveCircuitStatus>;
+}