@deepidealab/n8n-nodes-tracira 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 DeepIdea Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# @deepidealab/n8n-nodes-tracira
+
+This is an n8n community node for Tracira.
+
+Tracira monitors AI outputs from your automations, evaluates them against rules, and lets you inspect execution results from inside n8n workflows.
+
+[n8n](https://n8n.io/) is a [fair-code licensed](https://docs.n8n.io/sustainable-use-license/) workflow automation platform.
+
+## Installation
+
+Follow the [n8n community node installation guide](https://docs.n8n.io/integrations/community-nodes/installation/).
+
+Install package name:
+
+```text
+@deepidealab/n8n-nodes-tracira
+```
+
+If you already installed the legacy unscoped package `n8n-nodes-tracira`, uninstall it and install the scoped package instead.
+
+For local development:
+
+```bash
+npm install
+npm run verify
+```
+
+## Operations
+
+The node currently supports the `Execution` resource with these operations:
+
+- `Log`: Send an AI execution to Tracira for evaluation.
+- `Get`: Fetch a single execution by ID.
+- `Get Many`: List executions with filters such as status, flow, check, and date range.
+
+## Credentials
+
+Use the `Tracira API` credential.
+
+You need a workspace webhook token from your Tracira dashboard:
+
+1. Open Tracira.
+2. Go to the integrations/token area of your workspace.
+3. Copy the webhook token.
+4. Paste it into the `Workspace Token` field in n8n.
+
+The credential test calls `GET /api/verify` on Tracira and uses the token as a query parameter.
+
+## Compatibility
+
+This package is being set up against the current n8n community-node tooling and Tracira API endpoints available as of March 7, 2026.
+
+## Usage
+
+Typical pattern:
+
+1. Run your AI step in n8n.
+2. Send the model output to `Tracira -> Execution -> Log`.
+3. Branch on the returned `status`, `verdict`, or `confidenceScore`.
+4. Optionally query historic executions with `Get` or `Get Many`.
+
+Current scope intentionally focuses on token-authenticated operations. Human decision updates are not included yet because the corresponding Tracira backend route is not token-authenticated.
+
+## Example workflow
+
+An importable example workflow is available at [examples/log-and-branch.workflow.json](./examples/log-and-branch.workflow.json).
+
+The example does this:
+
+1. Starts from a manual trigger.
+2. Logs an execution to Tracira.
+3. Branches with an `If` node based on the returned `status`.
+
+## Verification notes
+
+This package is structured to align with n8n's verification guidance:
+
+- Built with the `n8n-node` toolchain.
+- No runtime `dependencies` in `package.json`.
+- No access to environment variables or file system from node code.
+- MIT licensed.
+- Published from GitHub Actions with npm provenance configured in `.github/workflows/publish.yml`.
+- The published package is scanned with `@n8n/scan-community-package` after npm publication.
+
+Maintainer release instructions are documented in [PUBLISHING.md](./PUBLISHING.md).
+
+## Resources
+
+- [n8n community nodes documentation](https://docs.n8n.io/integrations/#community-nodes)
+- [Tracira](https://www.tracira.com)
+- [Tracira API schema](https://www.tracira.com/openapi.json)
+
+## Version history
+
+### 0.2.0
+
+Move the package to the `@deepidealab` npm scope so the node is published under the business organization instead of a personal npm account.
+
+### 0.1.8
+
+Add codex categories and search aliases to improve Tracira discoverability in the editor node picker.
+
+### 0.1.7
+
+Remove the invalid `Developer Tools` node category so Tracira remains visible in the editor on self-hosted n8n.
+
+### 0.1.6
+
+Replace newer declarative node features with a plain execute-style implementation for broader self-hosted n8n compatibility.
+
+### 0.1.5
+
+Reduce node-description metadata to older-safe fields for self-hosted n8n compatibility.
+
+### 0.1.4
+
+Use a current npm CLI in the publish workflow to satisfy npm trusted publishing requirements.
+
+### 0.1.3
+
+Force GitHub Actions to publish via npm trusted publishing instead of any inherited token environment.
+
+### 0.1.2
+
+Allow GitHub Actions trusted publishing while continuing to block accidental local publishes.
+
+### 0.1.1
+
+First GitHub Actions release with npm provenance and trusted publishing.
+
+### 0.1.0
+
+Initial Tracira node setup with execution logging and read operations.

package/dist/credentials/TraciraApi.credentials.d.ts

@@ -0,0 +1,10 @@
+import type { IAuthenticateGeneric, ICredentialTestRequest, ICredentialType, Icon, INodeProperties } from 'n8n-workflow';
+export declare class TraciraApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    icon: Icon;
+    documentationUrl: string;
+    properties: INodeProperties[];
+    authenticate: IAuthenticateGeneric;
+    test: ICredentialTestRequest;
+}

package/dist/credentials/TraciraApi.credentials.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TraciraApi = void 0;
+class TraciraApi {
+    constructor() {
+        this.name = 'traciraApi';
+        this.displayName = 'Tracira API';
+        this.icon = { light: 'file:../nodes/Tracira/tracira.svg', dark: 'file:../nodes/Tracira/tracira.dark.svg' };
+        this.documentationUrl = 'https://github.com/deepidealab/n8n-nodes-tracira?tab=readme-ov-file#credentials';
+        this.properties = [
+            {
+                displayName: 'Workspace Token',
+                name: 'webhookToken',
+                type: 'string',
+                typeOptions: { password: true },
+                required: true,
+                default: '',
+                description: 'The webhook token from your Tracira workspace',
+            },
+        ];
+        this.authenticate = {
+            type: 'generic',
+            properties: {
+                qs: {
+                    token: '={{$credentials.webhookToken}}',
+                },
+            },
+        };
+        this.test = {
+            request: {
+                baseURL: 'https://www.tracira.com/api',
+                url: '/verify',
+                method: 'GET',
+            },
+        };
+    }
+}
+exports.TraciraApi = TraciraApi;
+//# sourceMappingURL=TraciraApi.credentials.js.map

package/dist/credentials/TraciraApi.credentials.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TraciraApi.credentials.js","sourceRoot":"","sources":["../../credentials/TraciraApi.credentials.ts"],"names":[],"mappings":";;;AAQA,MAAa,UAAU;IAAvB;QACC,SAAI,GAAG,YAAY,CAAC;QAEpB,gBAAW,GAAG,aAAa,CAAC;QAE5B,SAAI,GAAS,EAAE,KAAK,EAAE,mCAAmC,EAAE,IAAI,EAAE,wCAAwC,EAAE,CAAC;QAE5G,qBAAgB,GAAG,iFAAiF,CAAC;QAErG,eAAU,GAAsB;YAC/B;gBACC,WAAW,EAAE,iBAAiB;gBAC9B,IAAI,EAAE,cAAc;gBACpB,IAAI,EAAE,QAAQ;gBACd,WAAW,EAAE,EAAE,QAAQ,EAAE,IAAI,EAAE;gBAC/B,QAAQ,EAAE,IAAI;gBACd,OAAO,EAAE,EAAE;gBACX,WAAW,EAAE,+CAA+C;aAC5D;SACD,CAAC;QAEF,iBAAY,GAAyB;YACpC,IAAI,EAAE,SAAS;YACf,UAAU,EAAE;gBACX,EAAE,EAAE;oBACH,KAAK,EAAE,gCAAgC;iBACvC;aACD;SACD,CAAC;QAEF,SAAI,GAA2B;YAC9B,OAAO,EAAE;gBACR,OAAO,EAAE,6BAA6B;gBACtC,GAAG,EAAE,SAAS;gBACd,MAAM,EAAE,KAAK;aACb;SACD,CAAC;IACH,CAAC;CAAA;AArCD,gCAqCC"}

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

@@ -0,0 +1,5 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+export declare class Tracira implements INodeType {
+    description: INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/Tracira/Tracira.node.js

@@ -0,0 +1,470 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracira = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const baseUrl = 'https://www.tracira.com/api';
+const logDisplay = {
+    resource: ['execution'],
+    operation: ['log'],
+};
+const getDisplay = {
+    resource: ['execution'],
+    operation: ['get'],
+};
+const getAllDisplay = {
+    resource: ['execution'],
+    operation: ['getAll'],
+};
+function stripEmpty(data) {
+    return Object.fromEntries(Object.entries(data).filter(([, value]) => value !== '' && value !== undefined && value !== null));
+}
+class Tracira {
+    constructor() {
+        this.description = {
+            displayName: 'Tracira',
+            name: 'tracira',
+            icon: 'file:tracira.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Log and inspect Tracira AI execution data',
+            codex: {
+                categories: ['AI'],
+                resources: {
+                    credentialDocumentation: [
+                        {
+                            url: 'https://github.com/deepidealab/n8n-nodes-tracira?tab=readme-ov-file#credentials',
+                        },
+                    ],
+                    primaryDocumentation: [
+                        {
+                            url: 'https://github.com/deepidealab/n8n-nodes-tracira?tab=readme-ov-file',
+                        },
+                    ],
+                },
+                alias: ['Tracira AI', 'Tracera', 'AI monitoring', 'AI evaluation', 'LLM monitoring'],
+            },
+            defaults: {
+                name: 'Tracira',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'traciraApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Execution',
+                            value: 'execution',
+                        },
+                    ],
+                    default: 'execution',
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['execution'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Log',
+                            value: 'log',
+                            action: 'Log an execution',
+                            description: 'Send an AI execution to Tracira for evaluation',
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            action: 'Get an execution',
+                            description: 'Fetch a single execution by ID',
+                        },
+                        {
+                            name: 'Get Many',
+                            value: 'getAll',
+                            action: 'Get many an execution',
+                            description: 'List executions from Tracira',
+                        },
+                    ],
+                    default: 'log',
+                },
+                {
+                    displayName: 'Execution ID',
+                    name: 'executionId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: getDisplay,
+                    },
+                    description: 'The execution ID to fetch',
+                },
+                {
+                    displayName: 'Flow',
+                    name: 'flowName',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: logDisplay,
+                    },
+                    description: 'The Tracira flow name for this execution',
+                },
+                {
+                    displayName: 'Output',
+                    name: 'output',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 6,
+                    },
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: logDisplay,
+                    },
+                    description: 'The AI-generated output to evaluate in Tracira',
+                },
+                {
+                    displayName: 'Input',
+                    name: 'input',
+                    type: 'string',
+                    typeOptions: {
+                        rows: 4,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: logDisplay,
+                    },
+                    description: 'Optional prompt or input text that produced the output',
+                },
+                {
+                    displayName: 'Check',
+                    name: 'checkName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: logDisplay,
+                    },
+                    description: 'Optional Tracira check name',
+                },
+                {
+                    displayName: 'Model',
+                    name: 'modelName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: logDisplay,
+                    },
+                    description: 'Optional AI model name to record with the execution',
+                },
+                {
+                    displayName: 'Options',
+                    name: 'options',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    displayOptions: {
+                        show: logDisplay,
+                    },
+                    options: [
+                        {
+                            displayName: 'Actor ID',
+                            name: 'actorId',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Callback URL',
+                            name: 'callbackUrl',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Confidence',
+                            name: 'confidence',
+                            type: 'number',
+                            default: 0,
+                        },
+                        {
+                            displayName: 'Cost (USD)',
+                            name: 'costUsd',
+                            type: 'number',
+                            default: 0,
+                        },
+                        {
+                            displayName: 'Execution ID',
+                            name: 'id',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Latency',
+                            name: 'latencyMs',
+                            type: 'number',
+                            default: 0,
+                        },
+                        {
+                            displayName: 'Metadata JSON',
+                            name: 'metadataJson',
+                            type: 'string',
+                            typeOptions: {
+                                rows: 4,
+                            },
+                            default: '',
+                            description: 'Optional JSON object to store as execution metadata',
+                        },
+                        {
+                            displayName: 'Session ID',
+                            name: 'sessionId',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Subject ID',
+                            name: 'subjectId',
+                            type: 'string',
+                            default: '',
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Status',
+                    name: 'status',
+                    type: 'options',
+                    default: '',
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    options: [
+                        { name: 'All', value: '' },
+                        { name: 'Success', value: 'success' },
+                        { name: 'Flagged', value: 'flagged' },
+                        { name: 'Failed', value: 'failed' },
+                    ],
+                    description: 'Filter executions by status',
+                },
+                {
+                    displayName: 'Flow',
+                    name: 'flowFilter',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    description: 'Filter executions to a specific flow name',
+                },
+                {
+                    displayName: 'Check',
+                    name: 'checkFilter',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    description: 'Filter executions to a specific check name',
+                },
+                {
+                    displayName: 'Search Query',
+                    name: 'query',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    description: 'Search across flow, check, model, and context IDs',
+                },
+                {
+                    displayName: 'From',
+                    name: 'from',
+                    type: 'dateTime',
+                    default: '',
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    description: 'Only include executions at or after this date',
+                },
+                {
+                    displayName: 'To',
+                    name: 'to',
+                    type: 'dateTime',
+                    default: '',
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    description: 'Only include executions up to this date',
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 1,
+                        maxValue: 100,
+                    },
+                    default: 50,
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    description: 'Max number of results to return',
+                },
+                {
+                    displayName: 'Page',
+                    name: 'page',
+                    type: 'number',
+                    typeOptions: {
+                        minValue: 1,
+                    },
+                    default: 1,
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    description: 'Results page number',
+                },
+                {
+                    displayName: 'Additional Filters',
+                    name: 'filters',
+                    type: 'collection',
+                    placeholder: 'Add Filter',
+                    default: {},
+                    displayOptions: {
+                        show: getAllDisplay,
+                    },
+                    options: [
+                        {
+                            displayName: 'Actor ID',
+                            name: 'actorId',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Session ID',
+                            name: 'sessionId',
+                            type: 'string',
+                            default: '',
+                        },
+                        {
+                            displayName: 'Subject ID',
+                            name: 'subjectId',
+                            type: 'string',
+                            default: '',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
+            try {
+                const operation = this.getNodeParameter('operation', itemIndex);
+                let requestOptions;
+                if (operation === 'log') {
+                    const options = this.getNodeParameter('options', itemIndex, {});
+                    let metadata;
+                    if (options.metadataJson) {
+                        try {
+                            metadata = JSON.parse(options.metadataJson);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Metadata JSON must be valid JSON', {
+                                itemIndex,
+                            });
+                        }
+                    }
+                    requestOptions = {
+                        method: 'POST',
+                        url: `${baseUrl}/webhook`,
+                        body: stripEmpty({
+                            flow: this.getNodeParameter('flowName', itemIndex),
+                            output: this.getNodeParameter('output', itemIndex),
+                            input: this.getNodeParameter('input', itemIndex, ''),
+                            check: this.getNodeParameter('checkName', itemIndex, ''),
+                            model: this.getNodeParameter('modelName', itemIndex, ''),
+                            actorId: options.actorId,
+                            callbackUrl: options.callbackUrl,
+                            confidence: options.confidence,
+                            costUsd: options.costUsd,
+                            id: options.id,
+                            latencyMs: options.latencyMs,
+                            metadata,
+                            sessionId: options.sessionId,
+                            subjectId: options.subjectId,
+                        }),
+                    };
+                }
+                else if (operation === 'get') {
+                    const executionId = this.getNodeParameter('executionId', itemIndex);
+                    requestOptions = {
+                        method: 'GET',
+                        url: `${baseUrl}/executions/${encodeURIComponent(executionId)}`,
+                    };
+                }
+                else {
+                    const filters = this.getNodeParameter('filters', itemIndex, {});
+                    requestOptions = {
+                        method: 'GET',
+                        url: `${baseUrl}/executions`,
+                        qs: stripEmpty({
+                            status: this.getNodeParameter('status', itemIndex, ''),
+                            flow: this.getNodeParameter('flowFilter', itemIndex, ''),
+                            check: this.getNodeParameter('checkFilter', itemIndex, ''),
+                            q: this.getNodeParameter('query', itemIndex, ''),
+                            from: this.getNodeParameter('from', itemIndex, ''),
+                            to: this.getNodeParameter('to', itemIndex, ''),
+                            limit: this.getNodeParameter('limit', itemIndex, 50),
+                            page: this.getNodeParameter('page', itemIndex, 1),
+                            actorId: filters.actorId,
+                            sessionId: filters.sessionId,
+                            subjectId: filters.subjectId,
+                        }),
+                    };
+                }
+                const response = await this.helpers.httpRequestWithAuthentication.call(this, 'traciraApi', requestOptions);
+                if (operation === 'getAll' && Array.isArray(response === null || response === void 0 ? void 0 : response.executions)) {
+                    for (const execution of response.executions) {
+                        returnData.push({
+                            json: execution,
+                            pairedItem: itemIndex,
+                        });
+                    }
+                }
+                else {
+                    returnData.push({
+                        json: response,
+                        pairedItem: itemIndex,
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error.message,
+                        },
+                        pairedItem: itemIndex,
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error instanceof Error ? error.message : 'Unknown Tracira error', { itemIndex });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Tracira = Tracira;
+//# sourceMappingURL=Tracira.node.js.map