n8n-nodes-confirm8 0.13.0 → 0.16.0

package/dist/nodes/Confirm8Tool/Confirm8AgentTool.node.d.ts

@@ -0,0 +1,10 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription, IDataObject } from 'n8n-workflow';
+export declare class Confirm8AgentTool implements INodeType {
+    description: INodeTypeDescription;
+    /**
+     * Complete tool description for AI Agent
+     * The AI will use this to understand ALL available operations
+     */
+    getToolDescription(): IDataObject;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Confirm8Tool/Confirm8AgentTool.node.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Confirm8AgentTool = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+class Confirm8AgentTool {
+    constructor() {
+        this.description = {
+            displayName: 'Confirm8 AI Tool',
+            name: 'confirm8AgentTool',
+            icon: 'file:tool.svg',
+            group: ['transform'],
+            version: 1,
+            description: 'Autonomous AI Agent tool for Confirm8 API - AI decides everything',
+            defaults: {
+                name: 'Confirm8 AI Tool',
+            },
+            // CRITICAL: Makes this node usable as an AI Agent Tool
+            usableAsTool: true,
+            inputs: ['main'],
+            outputs: ['main'],
+            properties: [
+                // ONLY API Configuration - AI decides the rest
+                {
+                    displayName: 'Base URL',
+                    name: 'baseUrl',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'https://api.confirm8.com',
+                    required: true,
+                    description: 'Base URL of Confirm8 API',
+                },
+                {
+                    displayName: 'Bearer Token',
+                    name: 'bearerToken',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    default: '',
+                    required: true,
+                    description: 'Authentication token',
+                },
+                {
+                    displayName: 'X-API-DOMAIN',
+                    name: 'apiDomain',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                },
+                {
+                    displayName: 'X-APIKEY-TOKEN',
+                    name: 'apiKeyToken',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    default: '',
+                    required: true,
+                },
+            ],
+        };
+    }
+    /**
+     * Complete tool description for AI Agent
+     * The AI will use this to understand ALL available operations
+     */
+    getToolDescription() {
+        return {
+            name: 'confirm8_api',
+            description: 'Complete Confirm8 API access tool. Use this to interact with the Confirm8 system. ' +
+                'You can fetch, create, update, activate, or deactivate any resource. ' +
+                '\n\n**Available Resources:**\n' +
+                '- user (users/employees)\n' +
+                '- client (clients/customers)\n' +
+                '- item (items/products inventory)\n' +
+                '- itemType (item type categories)\n' +
+                '- task (tasks/checklists)\n' +
+                '- service (services)\n' +
+                '- product (products/insumos)\n' +
+                '- order (work orders/WOS)\n' +
+                '- modality (order modalities)\n' +
+                '- ticket (tickets/occurrences)\n' +
+                '- property (properties)\n' +
+                '\n**Available Operations:**\n' +
+                '- getAll: List all records (no ID needed)\n' +
+                '- get: Get single record (requires recordId)\n' +
+                '- create: Create new record (requires data)\n' +
+                '- update: Update existing record (requires recordId and data)\n' +
+                '- activate: Activate/enable record (requires recordId)\n' +
+                '- deactivate: Deactivate/disable record (requires recordId)\n' +
+                '\n**Special User Operations:**\n' +
+                '- getByUsername: Get user by username (requires username in data)\n' +
+                '- getTickets: Get user tickets (requires recordId)\n' +
+                '- getTasks: Get user tasks (requires recordId)\n' +
+                '- getPermissions: Get user permissions (requires recordId)\n' +
+                '- linkTasks: Link tasks to user (requires data with userId and taskIds)\n' +
+                '- deleteLinkedTasks: Delete all linked tasks\n' +
+                '- deleteLinkedTasksByUser: Delete tasks by user (requires employeeId in data)\n' +
+                '- uploadPhoto: Upload user photo (requires recordId and photo data)\n' +
+                '- uploadSignature: Upload user signature (requires recordId and signature data)\n' +
+                '\n**Examples:**\n' +
+                '- List all users: resource="user", operation="getAll"\n' +
+                '- Get client 123: resource="client", operation="get", recordId="123"\n' +
+                '- Create product: resource="product", operation="create", data={"name":"Product X","price":99.99}\n' +
+                '- Update task: resource="task", operation="update", recordId="456", data={"status":"completed"}\n' +
+                '- Activate user: resource="user", operation="activate", recordId="789"\n' +
+                '- Get user tickets: resource="user", operation="getTickets", recordId="123"',
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'string',
+                    required: true,
+                    description: 'Resource type: user, client, item, itemType, task, service, product, order, modality, ticket, or property',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'string',
+                    required: true,
+                    description: 'Operation: getAll, get, create, update, activate, deactivate, or special operations (getByUsername, getTickets, getTasks, etc.)',
+                },
+                {
+                    displayName: 'Record ID',
+                    name: 'recordId',
+                    type: 'string',
+                    required: false,
+                    description: 'ID of the record (required for get, update, activate, deactivate, and some special operations)',
+                },
+                {
+                    displayName: 'Data',
+                    name: 'data',
+                    type: 'json',
+                    required: false,
+                    description: 'JSON data for create/update operations or additional parameters. Example: {"name":"John","email":"john@example.com"}',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                // Get API configuration (only thing configured in the UI)
+                const baseUrl = this.getNodeParameter('baseUrl', i);
+                const bearerToken = this.getNodeParameter('bearerToken', i);
+                const apiDomain = this.getNodeParameter('apiDomain', i);
+                const apiKeyToken = this.getNodeParameter('apiKeyToken', i);
+                // Get operation parameters from the TOOL CALL (provided by AI)
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                const recordId = this.getNodeParameter('recordId', i, '');
+                // Parse data if provided
+                let data = {};
+                try {
+                    const dataParam = this.getNodeParameter('data', i, '');
+                    if (dataParam) {
+                        if (typeof dataParam === 'string') {
+                            data = JSON.parse(dataParam);
+                        }
+                        else if (typeof dataParam === 'object') {
+                            data = dataParam;
+                        }
+                    }
+                }
+                catch (e) {
+                    // Data is optional
+                }
+                // Map resource to API endpoint
+                const resourceMap = {
+                    user: 'users',
+                    client: 'clients',
+                    item: 'items',
+                    itemType: 'itemTypes',
+                    task: 'tasks',
+                    service: 'services',
+                    product: 'products',
+                    order: 'wos',
+                    modality: 'modalities',
+                    ticket: 'tickets',
+                    property: 'properties',
+                };
+                const baseEndpoint = resourceMap[resource] || resource;
+                let endpoint = '';
+                let method = 'GET';
+                let body = {};
+                // Build request based on operation
+                switch (operation) {
+                    case 'getAll':
+                        endpoint = `/${baseEndpoint}`;
+                        method = 'GET';
+                        break;
+                    case 'get':
+                        if (!recordId) {
+                            throw new Error('recordId is required for get operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}`;
+                        method = 'GET';
+                        break;
+                    case 'create':
+                        endpoint = `/${baseEndpoint}`;
+                        method = 'POST';
+                        body = data;
+                        break;
+                    case 'update':
+                        if (!recordId) {
+                            throw new Error('recordId is required for update operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}`;
+                        method = 'PUT';
+                        body = data;
+                        break;
+                    case 'activate':
+                        if (!recordId) {
+                            throw new Error('recordId is required for activate operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}/active`;
+                        // Different resources use different methods
+                        if (['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)) {
+                            method = 'PUT';
+                        }
+                        else {
+                            method = 'PATCH';
+                        }
+                        break;
+                    case 'deactivate':
+                        if (!recordId) {
+                            throw new Error('recordId is required for deactivate operation');
+                        }
+                        endpoint = `/${baseEndpoint}/${recordId}/inactive`;
+                        // Different resources use different methods
+                        if (['client', 'item', 'itemType', 'task', 'service', 'product', 'order', 'modality'].includes(resource)) {
+                            method = 'PUT';
+                        }
+                        else {
+                            method = 'PATCH';
+                        }
+                        break;
+                    // Special User Operations
+                    case 'getByUsername':
+                        if (!data.username) {
+                            throw new Error('username is required in data for getByUsername operation');
+                        }
+                        endpoint = `/users/${data.username}/user`;
+                        method = 'GET';
+                        break;
+                    case 'getTickets':
+                        if (!recordId) {
+                            throw new Error('recordId is required for getTickets operation');
+                        }
+                        endpoint = `/users/${recordId}/tickets`;
+                        method = 'GET';
+                        break;
+                    case 'getTasks':
+                        if (!recordId) {
+                            throw new Error('recordId is required for getTasks operation');
+                        }
+                        endpoint = `/users/${recordId}/tasks`;
+                        method = 'GET';
+                        break;
+                    case 'getPermissions':
+                        if (!recordId) {
+                            throw new Error('recordId is required for getPermissions operation');
+                        }
+                        endpoint = `/users/${recordId}/permissions`;
+                        method = 'GET';
+                        break;
+                    case 'linkTasks':
+                        endpoint = '/users/tasks';
+                        method = 'POST';
+                        body = data;
+                        break;
+                    case 'deleteLinkedTasks':
+                        endpoint = '/users/tasks';
+                        method = 'DELETE';
+                        break;
+                    case 'deleteLinkedTasksByUser':
+                        if (!data.employeeId) {
+                            throw new Error('employeeId is required in data for deleteLinkedTasksByUser operation');
+                        }
+                        endpoint = `/users/tasks/${data.employeeId}`;
+                        method = 'DELETE';
+                        break;
+                    case 'uploadPhoto':
+                        if (!recordId) {
+                            throw new Error('recordId is required for uploadPhoto operation');
+                        }
+                        endpoint = `/users/${recordId}/photos`;
+                        method = 'PATCH';
+                        body = data;
+                        break;
+                    case 'uploadSignature':
+                        if (!recordId) {
+                            throw new Error('recordId is required for uploadSignature operation');
+                        }
+                        endpoint = `/users/${recordId}/signatures`;
+                        method = 'PATCH';
+                        body = data;
+                        break;
+                    default:
+                        throw new Error(`Unknown operation: ${operation}`);
+                }
+                // Make HTTP request
+                const url = `${baseUrl}${endpoint}`;
+                const options = {
+                    method,
+                    uri: url,
+                    headers: {
+                        'Authorization': `Bearer ${bearerToken}`,
+                        'X-API-DOMAIN': apiDomain,
+                        'X-APIKEY-TOKEN': apiKeyToken,
+                        'Content-Type': 'application/json',
+                    },
+                    json: true,
+                };
+                if (method !== 'GET' && method !== 'DELETE' && Object.keys(body).length > 0) {
+                    options.body = body;
+                }
+                const responseData = await this.helpers.request(options);
+                returnData.push({
+                    json: {
+                        success: true,
+                        operation,
+                        resource,
+                        endpoint,
+                        data: responseData,
+                    },
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: error || 'Unknown error',
+                            resource: this.getNodeParameter('resource', i, ''),
+                            operation: this.getNodeParameter('operation', i, ''),
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Confirm8AgentTool = Confirm8AgentTool;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-confirm8",
-  "version": "0.13.0",
+  "version": "0.16.0",
   "description": "Simple n8n node for Confirm8 API - no credentials needed",
   "license": "MIT",
   "author": "Bill Hebert",
@@ -21,7 +21,8 @@
   },
   "n8n": {
     "nodes": [
-      "dist/nodes/Confirm8/ApiConfirm8.node.js"
+      "dist/nodes/Confirm8/ApiConfirm8.node.js",
+      "dist/nodes/Confirm8Tool/Confirm8AgentTool.node.js"
     ]
   },
   "peerDependencies": {