@tellzm/n8n-nodes 0.1.0-beta.0

package/dist/nodes/Axon/descriptions/routines.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlers = exports.properties = void 0;
+const apiRequest_js_1 = require("../helpers/apiRequest.js");
+const paginate_js_1 = require("../helpers/paginate.js");
+const scopeGuard_js_1 = require("../helpers/scopeGuard.js");
+const show = (ops) => ({
+    show: { resource: ["routine"], ...(ops ? { operation: ops } : {}) },
+});
+exports.properties = [
+    {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: show(),
+        default: "list",
+        options: [
+            { name: "Get", value: "get", action: "Get a routine" },
+            { name: "List", value: "list", action: "List routines" },
+            { name: "List Runs", value: "listRuns", action: "List runs" },
+            { name: "Submit Task Value", value: "submitTaskValue", action: "Submit a routine task value" },
+            { name: "Update Routine Task", value: "updateRoutineTask", action: "Update a routine task" },
+        ],
+    },
+    {
+        displayName: "Routine ID",
+        name: "routineId",
+        type: "string",
+        required: true,
+        default: "",
+        description: "The id of the routine",
+        displayOptions: show(["get", "listRuns", "submitTaskValue", "updateRoutineTask"]),
+    },
+    {
+        displayName: "Run ID",
+        name: "runId",
+        type: "string",
+        required: true,
+        default: "",
+        description: "The id of the routine run",
+        displayOptions: show(["submitTaskValue"]),
+    },
+    {
+        displayName: "Task ID",
+        name: "routineTaskId",
+        type: "string",
+        required: true,
+        default: "",
+        description: "The id of the routine task",
+        displayOptions: show(["submitTaskValue", "updateRoutineTask"]),
+    },
+    {
+        displayName: "Task Value (JSON)",
+        name: "taskValue",
+        type: "json",
+        default: "{}",
+        required: true,
+        description: "The value submitted for the routine task",
+        displayOptions: show(["submitTaskValue"]),
+    },
+    {
+        displayName: "Routine Task Body (JSON)",
+        name: "routineTaskBody",
+        type: "json",
+        default: "{}",
+        required: true,
+        description: "Routine task fields to update",
+        displayOptions: show(["updateRoutineTask"]),
+    },
+];
+async function get(i) {
+    await scopeGuard_js_1.assertScope.call(this, "routines.read");
+    const id = this.getNodeParameter("routineId", i);
+    const res = (await apiRequest_js_1.apiRequest.call(this, "GET", `/routines/${id}`));
+    return [{ json: (res.data ?? res) }];
+}
+async function list() {
+    await scopeGuard_js_1.assertScope.call(this, "routines.read");
+    const items = await (0, paginate_js_1.paginate)(this, "/routines");
+    return items.map((r) => ({ json: r }));
+}
+async function listRuns(i) {
+    await scopeGuard_js_1.assertScope.call(this, "routines.read");
+    const id = this.getNodeParameter("routineId", i);
+    const items = await (0, paginate_js_1.paginate)(this, `/routines/${id}/runs`);
+    return items.map((r) => ({ json: r }));
+}
+async function submitTaskValue(i) {
+    await scopeGuard_js_1.assertScope.call(this, "routines.write");
+    const runId = this.getNodeParameter("runId", i);
+    const taskId = this.getNodeParameter("routineTaskId", i);
+    const value = this.getNodeParameter("taskValue", i);
+    const res = (await apiRequest_js_1.apiRequest.call(this, "POST", `/routine-runs/${runId}/tasks/${taskId}/value`, { body: { value } }));
+    return [{ json: (res.data ?? res) }];
+}
+async function updateRoutineTask(i) {
+    await scopeGuard_js_1.assertScope.call(this, "routines.write");
+    const routineId = this.getNodeParameter("routineId", i);
+    const taskId = this.getNodeParameter("routineTaskId", i);
+    const body = this.getNodeParameter("routineTaskBody", i);
+    const res = (await apiRequest_js_1.apiRequest.call(this, "PATCH", `/routines/${routineId}/tasks/${taskId}`, { body }));
+    return [{ json: (res.data ?? res) }];
+}
+exports.handlers = { get, list, listRuns, submitTaskValue, updateRoutineTask };

package/dist/nodes/Axon/descriptions/tasks.d.ts

@@ -0,0 +1,19 @@
+import type { IExecuteFunctions, INodeExecutionData, INodeProperties } from "n8n-workflow";
+export declare const properties: INodeProperties[];
+declare function get(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]>;
+declare function list(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]>;
+declare function search(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]>;
+declare function create(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]>;
+declare function update(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]>;
+declare function del(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]>;
+declare function complete(this: IExecuteFunctions, i: number): Promise<INodeExecutionData[]>;
+export declare const handlers: {
+    get: typeof get;
+    list: typeof list;
+    search: typeof search;
+    create: typeof create;
+    update: typeof update;
+    delete: typeof del;
+    complete: typeof complete;
+};
+export {};

package/dist/nodes/Axon/descriptions/tasks.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlers = exports.properties = void 0;
+const apiRequest_js_1 = require("../helpers/apiRequest.js");
+const paginate_js_1 = require("../helpers/paginate.js");
+const scopeGuard_js_1 = require("../helpers/scopeGuard.js");
+const idempotency_js_1 = require("../helpers/idempotency.js");
+const showOn = (resource, ops) => ({
+    show: {
+        resource: [resource],
+        ...(ops ? { operation: ops } : {}),
+    },
+});
+exports.properties = [
+    {
+        displayName: "Operation",
+        name: "operation",
+        type: "options",
+        noDataExpression: true,
+        displayOptions: showOn("task"),
+        default: "list",
+        options: [
+            { name: "Get", value: "get", description: "Get one task by id", action: "Get a task" },
+            { name: "List", value: "list", description: "List tasks with filters; paginates transparently", action: "List tasks" },
+            { name: "Search", value: "search", description: "Full-text search across tasks", action: "Search tasks" },
+            { name: "Create", value: "create", description: "Create a new task", action: "Create a task" },
+            { name: "Update", value: "update", description: "Update an existing task", action: "Update a task" },
+            { name: "Delete", value: "delete", description: "Soft-delete a task", action: "Delete a task" },
+            { name: "Complete", value: "complete", description: "Mark a task as done", action: "Complete a task" },
+        ],
+    },
+    {
+        displayName: "Task ID",
+        name: "taskId",
+        type: "string",
+        required: true,
+        default: "",
+        description: "The id of the task",
+        displayOptions: showOn("task", ["get", "update", "delete", "complete"]),
+    },
+    {
+        displayName: "Project ID",
+        name: "projectId",
+        type: "string",
+        default: "",
+        description: "Filter to tasks in this project (optional)",
+        displayOptions: showOn("task", ["list"]),
+    },
+    {
+        displayName: "Status",
+        name: "status",
+        type: "options",
+        default: "",
+        description: "Filter to tasks with this status",
+        options: [
+            { name: "(Any)", value: "" },
+            { name: "Todo", value: "todo" },
+            { name: "In Progress", value: "in_progress" },
+            { name: "Done", value: "done" },
+            { name: "Blocked", value: "blocked" },
+        ],
+        displayOptions: showOn("task", ["list"]),
+    },
+    {
+        displayName: "Assignee ID",
+        name: "assigneeId",
+        type: "string",
+        default: "",
+        description: "Filter to tasks assigned to this user (optional)",
+        displayOptions: showOn("task", ["list"]),
+    },
+    {
+        displayName: "Search Query",
+        name: "q",
+        type: "string",
+        required: true,
+        default: "",
+        description: "Text to search for in task titles + descriptions",
+        displayOptions: showOn("task", ["search"]),
+    },
+    {
+        displayName: "Task Body (JSON)",
+        name: "taskBody",
+        type: "json",
+        default: '{\n  "title": "",\n  "projectId": ""\n}',
+        required: true,
+        description: "Task fields. For create: title and projectId are required; description, assigneeId, dueDate, priority, status, tags[] are optional.",
+        displayOptions: showOn("task", ["create", "update"]),
+    },
+];
+async function get(i) {
+    await scopeGuard_js_1.assertScope.call(this, "tasks.read");
+    const id = this.getNodeParameter("taskId", i);
+    const res = (await apiRequest_js_1.apiRequest.call(this, "GET", `/tasks/${id}`));
+    return [{ json: (res.data ?? res) }];
+}
+async function list(i) {
+    await scopeGuard_js_1.assertScope.call(this, "tasks.read");
+    const projectId = this.getNodeParameter("projectId", i, "");
+    const status = this.getNodeParameter("status", i, "");
+    const assigneeId = this.getNodeParameter("assigneeId", i, "");
+    const qs = {};
+    if (projectId)
+        qs.projectId = projectId;
+    if (status)
+        qs.status = status;
+    if (assigneeId)
+        qs.assigneeId = assigneeId;
+    const items = await (0, paginate_js_1.paginate)(this, "/tasks", qs);
+    return items.map((t) => ({ json: t }));
+}
+async function search(i) {
+    await scopeGuard_js_1.assertScope.call(this, "tasks.read");
+    const q = this.getNodeParameter("q", i);
+    const items = await (0, paginate_js_1.paginate)(this, "/tasks/search", { q });
+    return items.map((t) => ({ json: t }));
+}
+async function create(i) {
+    await scopeGuard_js_1.assertScope.call(this, "tasks.write");
+    const body = this.getNodeParameter("taskBody", i);
+    const key = (0, idempotency_js_1.deriveIdempotencyKey)(this, i, "task.create");
+    const res = (await apiRequest_js_1.apiRequest.call(this, "POST", "/tasks", { body, idempotencyKey: key }));
+    return [{ json: (res.data ?? res) }];
+}
+async function update(i) {
+    await scopeGuard_js_1.assertScope.call(this, "tasks.write");
+    const id = this.getNodeParameter("taskId", i);
+    const body = this.getNodeParameter("taskBody", i);
+    const res = (await apiRequest_js_1.apiRequest.call(this, "PATCH", `/tasks/${id}`, { body }));
+    return [{ json: (res.data ?? res) }];
+}
+async function del(i) {
+    await scopeGuard_js_1.assertScope.call(this, "tasks.write");
+    const id = this.getNodeParameter("taskId", i);
+    await apiRequest_js_1.apiRequest.call(this, "DELETE", `/tasks/${id}`);
+    return [{ json: { ok: true, id, deleted: true } }];
+}
+async function complete(i) {
+    await scopeGuard_js_1.assertScope.call(this, "tasks.write");
+    const id = this.getNodeParameter("taskId", i);
+    const res = (await apiRequest_js_1.apiRequest.call(this, "PATCH", `/tasks/${id}`, { body: { status: "done" } }));
+    return [{ json: (res.data ?? res) }];
+}
+exports.handlers = { get, list, search, create, update, "delete": del, complete };

package/dist/nodes/Axon/helpers/apiRequest.d.ts

@@ -0,0 +1,10 @@
+import type { IExecuteFunctions, IHookFunctions, ILoadOptionsFunctions, IHttpRequestMethods, JsonObject } from "n8n-workflow";
+type Ctx = IExecuteFunctions | IHookFunctions | ILoadOptionsFunctions;
+export type AxonRequestOptions = {
+    qs?: Record<string, unknown>;
+    body?: unknown;
+    idempotencyKey?: string;
+    headers?: Record<string, string>;
+};
+export declare function apiRequest(this: Ctx, method: IHttpRequestMethods, path: string, options?: AxonRequestOptions): Promise<JsonObject | JsonObject[]>;
+export {};

package/dist/nodes/Axon/helpers/apiRequest.js

@@ -0,0 +1,86 @@
+"use strict";
+// Centralized request helper for every Axon action node. Wraps n8n's
+// built-in OAuth2 request helper with three platform-specific niceties:
+//
+//   1. Auto-refresh: n8n's requestOAuth2 already refreshes on 401, but we
+//      surface a clean "credential revoked" error if the refresh itself
+//      fails (workspace admin revoked the connection).
+//   2. Retry-After: on 429/503 with Retry-After, sleep and retry ONCE.
+//      The platform's per-credential limiter (T013) issues these.
+//   3. Idempotency-Key: if the caller passes one, forward as a header.
+//
+// Surface-area parity with n8n's `IExecuteFunctions.helpers.requestOAuth2`,
+// but with our extra behavior layered on top.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRequest = apiRequest;
+const n8n_workflow_1 = require("n8n-workflow");
+const DEFAULT_BASE = "https://api.tellzm.com";
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function apiRequest(method, path, options = {}) {
+    const base = (process.env["AXON_API_BASE"] ?? DEFAULT_BASE).replace(/\/$/, "");
+    const url = path.startsWith("http") ? path : `${base}${path.startsWith("/") ? path : "/" + path}`;
+    const headers = {
+        "content-type": "application/json",
+        ...(options.headers ?? {}),
+    };
+    if (options.idempotencyKey)
+        headers["idempotency-key"] = options.idempotencyKey;
+    const opts = {
+        method,
+        url,
+        headers,
+        qs: options.qs ?? undefined,
+        body: options.body,
+        json: true,
+        returnFullResponse: true,
+    };
+    async function doRequest() {
+        return this.helpers.requestOAuth2.call(this, "axonOAuth2Api", opts);
+    }
+    let response;
+    try {
+        response = (await doRequest.call(this));
+    }
+    catch (err) {
+        // n8n's helper throws on non-2xx with .response populated.
+        const errAny = err;
+        const status = errAny.statusCode ?? errAny.response?.status;
+        if (status === 401) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), "Axon credential is invalid or has been revoked. Re-create the credential to continue.", { description: errAny.message ?? "" });
+        }
+        if (status === 429 || status === 503) {
+            // Retry once after Retry-After.
+            const retryAfter = parseRetryAfter(errAny.response?.body) ?? 5;
+            await sleep(Math.min(retryAfter * 1000, 60000));
+            try {
+                response = (await doRequest.call(this));
+            }
+            catch (err2) {
+                throw new n8n_workflow_1.NodeApiError(this.getNode(), err2, {
+                    message: `Axon API still rate-limited after Retry-After (${retryAfter}s).`,
+                });
+            }
+        }
+        else {
+            throw new n8n_workflow_1.NodeApiError(this.getNode(), errAny);
+        }
+    }
+    // Hard-cap on 4xx/5xx that slipped through the helper (defensive).
+    if (response.statusCode >= 400) {
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), { statusCode: response.statusCode, body: response.body });
+    }
+    return response.body;
+}
+function parseRetryAfter(body) {
+    // The API includes Retry-After in the response header, but n8n's helper
+    // already follows it. This fallback inspects the body for a hint just in
+    // case the receiver passed it through.
+    if (body && typeof body === "object" && "retryAfter" in body) {
+        const v = body.retryAfter;
+        if (typeof v === "number")
+            return v;
+    }
+    return null;
+}

package/dist/nodes/Axon/helpers/idempotency.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions } from "n8n-workflow";
+export declare function deriveIdempotencyKey(ctx: IExecuteFunctions, itemIndex: number, operation: string): string;

package/dist/nodes/Axon/helpers/idempotency.js

@@ -0,0 +1,15 @@
+"use strict";
+// Deterministic idempotency key derived from the n8n execution context.
+// When n8n retries a workflow execution (e.g. on a transient failure), the
+// same key is produced so the platform's MCP idempotency cache returns the
+// original result instead of re-executing.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveIdempotencyKey = deriveIdempotencyKey;
+const node_crypto_1 = require("node:crypto");
+function deriveIdempotencyKey(ctx, itemIndex, operation) {
+    const workflow = ctx.getWorkflow();
+    const node = ctx.getNode();
+    const executionId = ctx.getExecutionId();
+    const seed = `${workflow.id ?? "wf"}|${executionId}|${node.name}|${operation}|${itemIndex}`;
+    return (0, node_crypto_1.createHash)("sha256").update(seed).digest("hex").slice(0, 32);
+}

package/dist/nodes/Axon/helpers/paginate.d.ts

@@ -0,0 +1,2 @@
+import type { IExecuteFunctions } from "n8n-workflow";
+export declare function paginate<T = Record<string, unknown>>(ctx: IExecuteFunctions, path: string, baseQs?: Record<string, unknown>): Promise<T[]>;

package/dist/nodes/Axon/helpers/paginate.js

@@ -0,0 +1,26 @@
+"use strict";
+// Cursor-based pagination iterator for /list operations.
+// Walks `nextCursor` until the API stops returning one, yielding each page's
+// items. Returns the full array — n8n's per-item memory is the user's
+// constraint, not ours.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paginate = paginate;
+const apiRequest_js_1 = require("./apiRequest.js");
+const MAX_PAGES = 500; // safety cap so a buggy server can't loop us forever
+async function paginate(ctx, path, baseQs = {}) {
+    const all = [];
+    let cursor;
+    for (let page = 0; page < MAX_PAGES; page++) {
+        const qs = { ...baseQs };
+        if (cursor)
+            qs.cursor = cursor;
+        const res = (await apiRequest_js_1.apiRequest.call(ctx, "GET", path, { qs }));
+        const envelope = "data" in res ? res.data : res;
+        all.push(...envelope.items);
+        cursor = envelope.nextCursor;
+        if (!cursor)
+            return all;
+    }
+    // Hit the cap — return what we have and let the workflow see a warning.
+    return all;
+}

package/dist/nodes/Axon/helpers/scopeGuard.d.ts

@@ -0,0 +1,12 @@
+import type { IExecuteFunctions, IHookFunctions, ILoadOptionsFunctions } from "n8n-workflow";
+type Ctx = IExecuteFunctions | IHookFunctions | ILoadOptionsFunctions;
+/**
+ * Read the granted scope set from the active credential and throw if the
+ * required scope isn't there. Called by every action handler before its
+ * apiRequest invocation.
+ *
+ * Scopes are stored as a space-separated string on the credential (n8n's
+ * default oauth2Api format), so we tokenize before checking.
+ */
+export declare function assertScope(this: Ctx, required: string): Promise<void>;
+export {};

package/dist/nodes/Axon/helpers/scopeGuard.js

@@ -0,0 +1,24 @@
+"use strict";
+// Fail-fast scope check. Avoids hitting the API at all when the credential
+// doesn't carry the required scope — the user gets an actionable n8n error
+// before the network round-trip.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertScope = assertScope;
+const n8n_workflow_1 = require("n8n-workflow");
+/**
+ * Read the granted scope set from the active credential and throw if the
+ * required scope isn't there. Called by every action handler before its
+ * apiRequest invocation.
+ *
+ * Scopes are stored as a space-separated string on the credential (n8n's
+ * default oauth2Api format), so we tokenize before checking.
+ */
+async function assertScope(required) {
+    const creds = (await this.getCredentials("axonOAuth2Api"));
+    const granted = new Set((creds.scope ?? "").split(/\s+/).filter(Boolean));
+    if (!granted.has(required)) {
+        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `This operation requires the "${required}" scope, but the credential doesn't have it.`, {
+            description: "Edit the Axon OAuth2 API credential, add the missing scope to the Scope field, and reconnect.",
+        });
+    }
+}

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

@@ -0,0 +1,12 @@
+import type { IHookFunctions, INodeType, INodeTypeDescription, IWebhookFunctions, IWebhookResponseData } from "n8n-workflow";
+export declare class AxonTrigger implements INodeType {
+    description: INodeTypeDescription;
+    webhookMethods: {
+        default: {
+            create(this: IHookFunctions): Promise<boolean>;
+            delete(this: IHookFunctions): Promise<boolean>;
+            checkExists(this: IHookFunctions): Promise<boolean>;
+        };
+    };
+    webhook(this: IWebhookFunctions): Promise<IWebhookResponseData>;
+}

package/dist/nodes/AxonTrigger/AxonTrigger.node.js

@@ -0,0 +1,131 @@
+"use strict";
+// AxonTrigger node. Registers itself as a webhook subscriber on workflow
+// activate, receives deliveries via n8n's webhook endpoint, verifies HMAC,
+// and emits one n8n execution per delivery.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AxonTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const eventTypes_js_1 = require("./eventTypes.js");
+const signatureVerify_js_1 = require("./helpers/signatureVerify.js");
+const DEFAULT_BASE = "https://api.tellzm.com";
+class AxonTrigger {
+    constructor() {
+        this.description = {
+            displayName: "Axon Trigger",
+            name: "axonTrigger",
+            icon: "file:axon.svg",
+            group: ["trigger"],
+            version: 1,
+            description: "Fire workflows on Axon events (tasks, forms, processes, …).",
+            defaults: { name: "Axon Trigger" },
+            inputs: [],
+            outputs: ["main"],
+            credentials: [{ name: "axonOAuth2Api", required: true }],
+            webhooks: [
+                {
+                    name: "default",
+                    httpMethod: "POST",
+                    responseMode: "onReceived",
+                    path: "axon",
+                },
+            ],
+            properties: [
+                {
+                    displayName: "Event",
+                    name: "eventType",
+                    type: "options",
+                    default: "task.created",
+                    required: true,
+                    description: "Which Axon event to subscribe to",
+                    options: eventTypes_js_1.KNOWN_TRIGGER_EVENT_TYPES.map((e) => ({ name: e, value: e })),
+                },
+                {
+                    displayName: "Filters (JSON)",
+                    name: "filtersJson",
+                    type: "json",
+                    default: "",
+                    description: 'Optional filter tree. JSON with shape: { combinator: "AND" | "OR", conditions: [...] } or a single leaf { field, op, value }. Leave blank to deliver every event of this type. See docs.tellzm.com/n8n for the filter syntax.',
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async create() {
+                    const webhookUrl = this.getNodeWebhookUrl("default");
+                    const eventType = this.getNodeParameter("eventType");
+                    const filtersRaw = this.getNodeParameter("filtersJson", "");
+                    let filters = null;
+                    const trimmed = (filtersRaw ?? "").trim();
+                    if (trimmed) {
+                        try {
+                            filters = JSON.parse(trimmed);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Filters must be valid JSON. Got: ${trimmed.slice(0, 80)}`);
+                        }
+                    }
+                    const base = (process.env["AXON_API_BASE"] ?? DEFAULT_BASE).replace(/\/$/, "");
+                    const res = (await this.helpers.requestOAuth2.call(this, "axonOAuth2Api", {
+                        method: "POST",
+                        url: `${base}/webhook-subscriptions`,
+                        headers: { "content-type": "application/json" },
+                        body: { url: webhookUrl, eventType, filters },
+                        json: true,
+                    }));
+                    const dto = "data" in res ? res.data : res;
+                    const wd = this.getWorkflowStaticData("node");
+                    wd.endpointId = dto.endpointId;
+                    wd.secret = dto.secret;
+                    return true;
+                },
+                async delete() {
+                    const wd = this.getWorkflowStaticData("node");
+                    const endpointId = wd.endpointId;
+                    if (!endpointId)
+                        return true;
+                    const base = (process.env["AXON_API_BASE"] ?? DEFAULT_BASE).replace(/\/$/, "");
+                    try {
+                        await this.helpers.requestOAuth2.call(this, "axonOAuth2Api", {
+                            method: "DELETE",
+                            url: `${base}/webhook-subscriptions/${endpointId}`,
+                            json: true,
+                        });
+                    }
+                    catch {
+                        // Endpoint may already be gone server-side; that's fine.
+                    }
+                    wd.endpointId = undefined;
+                    wd.secret = undefined;
+                    return true;
+                },
+                async checkExists() {
+                    const wd = this.getWorkflowStaticData("node");
+                    return Boolean(wd.endpointId);
+                },
+            },
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const headers = req.headers;
+        const sig = headers["x-axon-signature"];
+        if (typeof sig !== "string") {
+            // No signature header — reject.
+            return { workflowData: [[{ json: { error: "missing signature" } }]] };
+        }
+        const wd = this.getWorkflowStaticData("node");
+        const secret = wd.secret;
+        if (!secret) {
+            return { workflowData: [[{ json: { error: "no stored secret" } }]] };
+        }
+        const body = req.body;
+        const rawBody = JSON.stringify(body);
+        if (!(0, signatureVerify_js_1.verifySignature)(secret, rawBody, sig)) {
+            return { workflowData: [[{ json: { error: "invalid signature" } }]] };
+        }
+        return {
+            workflowData: [[{ json: body }]],
+        };
+    }
+}
+exports.AxonTrigger = AxonTrigger;

package/dist/nodes/AxonTrigger/eventTypes.d.ts

@@ -0,0 +1,2 @@
+export declare const KNOWN_TRIGGER_EVENT_TYPES: readonly ["task.created", "task.updated", "task.completed", "task.deleted", "project.created", "comment.added", "form.submitted", "process_instance.created", "process_instance.transitioned", "page.published", "routine.run.completed", "record.upserted", "calendar.event.created"];
+export type KnownTriggerEventType = (typeof KNOWN_TRIGGER_EVENT_TYPES)[number];

package/dist/nodes/AxonTrigger/eventTypes.js

@@ -0,0 +1,22 @@
+"use strict";
+// The catalog of trigger event types this node supports. Mirrors the
+// platform's KNOWN_TRIGGER_EVENT_TYPES in @axon/shared-types — duplicated
+// here so the n8n package has no peer-dep on shared-types at runtime
+// (n8n's plugin loader prefers fully self-contained packages).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_TRIGGER_EVENT_TYPES = void 0;
+exports.KNOWN_TRIGGER_EVENT_TYPES = [
+    "task.created",
+    "task.updated",
+    "task.completed",
+    "task.deleted",
+    "project.created",
+    "comment.added",
+    "form.submitted",
+    "process_instance.created",
+    "process_instance.transitioned",
+    "page.published",
+    "routine.run.completed",
+    "record.upserted",
+    "calendar.event.created",
+];

package/dist/nodes/AxonTrigger/helpers/signatureVerify.d.ts

@@ -0,0 +1 @@
+export declare function verifySignature(secret: string, body: string, header: string): boolean;

package/dist/nodes/AxonTrigger/helpers/signatureVerify.js

@@ -0,0 +1,20 @@
+"use strict";
+// HMAC-SHA256 signature verification for inbound platform deliveries.
+// Mirrors the platform's outbound-webhook-signer with the same algorithm
+// + constant-time comparison.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = verifySignature;
+const node_crypto_1 = require("node:crypto");
+function verifySignature(secret, body, header) {
+    if (!header.startsWith("sha256="))
+        return false;
+    const expected = "sha256=" + (0, node_crypto_1.createHmac)("sha256", secret).update(body).digest("hex");
+    if (expected.length !== header.length)
+        return false;
+    try {
+        return (0, node_crypto_1.timingSafeEqual)(Buffer.from(expected), Buffer.from(header));
+    }
+    catch {
+        return false;
+    }
+}