@atom8n/n8n 2.4.7 → 2.5.1

package/dist/controllers/cli.controller.js

@@ -0,0 +1,334 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var CliController_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliController = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const db_1 = require("@n8n/db");
+const decorators_1 = require("@n8n/decorators");
+const uuid_1 = require("uuid");
+const n8n_workflow_1 = require("n8n-workflow");
+const active_executions_1 = require("../active-executions");
+const ownership_service_1 = require("../services/ownership.service");
+const utils_1 = require("../utils");
+const workflow_runner_1 = require("../workflow-runner");
+let CliController = CliController_1 = class CliController {
+    constructor(logger, workflowRepository, sharedWorkflowRepository, projectRepository, executionRepository, ownershipService, activeExecutions, workflowRunner) {
+        this.logger = logger;
+        this.workflowRepository = workflowRepository;
+        this.sharedWorkflowRepository = sharedWorkflowRepository;
+        this.projectRepository = projectRepository;
+        this.executionRepository = executionRepository;
+        this.ownershipService = ownershipService;
+        this.activeExecutions = activeExecutions;
+        this.workflowRunner = workflowRunner;
+    }
+    isWebhookBasedTrigger(nodeType) {
+        return (nodeType === n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE ||
+            nodeType === 'n8n-nodes-base.webhook' ||
+            nodeType.toLowerCase().includes('webhook'));
+    }
+    isLocalRequest(req) {
+        const remoteAddress = req.ip || req.socket.remoteAddress || '';
+        return (remoteAddress === '127.0.0.1' ||
+            remoteAddress === '::1' ||
+            remoteAddress === '::ffff:127.0.0.1' ||
+            remoteAddress === 'localhost');
+    }
+    async run(req, res) {
+        const startTime = Date.now();
+        this.logger.info('[cli] ── RUN REQUEST ──');
+        if (!this.isLocalRequest(req)) {
+            res.status(403).json({ error: 'CLI endpoint is only accessible from localhost' });
+            return;
+        }
+        const body = req.body;
+        if (!body.workflowData) {
+            res.status(400).json({ error: 'Missing workflowData in request body' });
+            return;
+        }
+        const fileData = body.workflowData;
+        const chatInput = body.chatInput;
+        const inputData = body.inputData;
+        this.logger.info(`[cli] inputData: ${inputData ? JSON.stringify(inputData) : '(none)'}`);
+        if (!fileData.nodes || !Array.isArray(fileData.nodes)) {
+            res.status(400).json({ error: 'Workflow does not contain valid nodes' });
+            return;
+        }
+        if (!fileData.connections || typeof fileData.connections !== 'object') {
+            res.status(400).json({ error: 'Workflow does not contain valid connections' });
+            return;
+        }
+        this.logger.info(`[cli] Workflow: "${fileData.name}", Nodes: ${fileData.nodes.length}`);
+        try {
+            const user = await this.ownershipService.getInstanceOwner();
+            const workflowId = await this.syncWorkflow(fileData, user.id);
+            const workflow = await this.workflowRepository.findOneBy({ id: workflowId });
+            if (!workflow) {
+                res.status(500).json({ error: 'Failed to sync workflow to database' });
+                return;
+            }
+            this.logger.info(`[cli] Synced workflow: "${workflow.name}" (ID: ${workflowId})`);
+            const triggerNode = workflow.nodes.find((node) => node.type.toLowerCase().includes('trigger') ||
+                node.type.toLowerCase().includes('webhook') ||
+                node.type === 'n8n-nodes-base.start');
+            if (!triggerNode) {
+                res.status(400).json({ error: 'No trigger node found in workflow' });
+                return;
+            }
+            this.logger.info(`[cli] Trigger: "${triggerNode.name}" (${triggerNode.type})`);
+            let executionId;
+            if (this.isWebhookBasedTrigger(triggerNode.type)) {
+                this.logger.info('[cli] Using direct execution (webhook/chat trigger)');
+                const isChatTrigger = triggerNode.type === n8n_workflow_1.CHAT_TRIGGER_NODE_TYPE;
+                const mockData = isChatTrigger
+                    ? {
+                        sessionId: `cli-${Date.now()}`,
+                        action: 'sendMessage',
+                        chatInput: chatInput ?? 'CLI execution',
+                    }
+                    : {
+                        headers: {},
+                        params: {},
+                        query: {},
+                        body: { chatInput },
+                    };
+                const executionData = (0, n8n_workflow_1.createRunExecutionData)({
+                    startData: {},
+                    resultData: {
+                        pinData: { [triggerNode.name]: [{ json: mockData }] },
+                        runData: {},
+                    },
+                    executionData: {
+                        contextData: {},
+                        metadata: {},
+                        nodeExecutionStack: [
+                            {
+                                node: triggerNode,
+                                data: {
+                                    main: [[{ json: mockData }]],
+                                },
+                                source: null,
+                            },
+                        ],
+                        waitingExecution: {},
+                        waitingExecutionSource: {},
+                    },
+                });
+                const runData = {
+                    executionMode: isChatTrigger ? 'chat' : 'webhook',
+                    workflowData: workflow,
+                    userId: user.id,
+                    startNodes: [{ name: triggerNode.name, sourceData: null }],
+                    pinData: { [triggerNode.name]: [{ json: mockData }] },
+                    executionData,
+                };
+                executionId = await this.workflowRunner.run(runData);
+            }
+            else {
+                this.logger.info('[cli] Using trigger execution (regular trigger)');
+                const triggerData = (inputData ?? {});
+                if (chatInput !== undefined && !inputData) {
+                    triggerData.chatInput = chatInput;
+                }
+                this.logger.info(`[cli] Trigger input data: ${JSON.stringify(triggerData)}`);
+                const executionData = (0, n8n_workflow_1.createRunExecutionData)({
+                    startData: {},
+                    resultData: {
+                        pinData: { [triggerNode.name]: [{ json: triggerData }] },
+                        runData: {},
+                    },
+                    executionData: {
+                        contextData: {},
+                        metadata: {},
+                        nodeExecutionStack: [
+                            {
+                                node: triggerNode,
+                                data: {
+                                    main: [[{ json: triggerData }]],
+                                },
+                                source: null,
+                            },
+                        ],
+                        waitingExecution: {},
+                        waitingExecutionSource: {},
+                    },
+                });
+                const runData = {
+                    executionMode: 'trigger',
+                    workflowData: workflow,
+                    userId: user.id,
+                    startNodes: [{ name: triggerNode.name, sourceData: null }],
+                    pinData: { [triggerNode.name]: [{ json: triggerData }] },
+                    executionData,
+                };
+                executionId = await this.workflowRunner.run(runData);
+            }
+            this.logger.info(`[cli] Execution started: ${executionId}`);
+            let timeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+                timeoutId = setTimeout(() => {
+                    reject(new Error(`Execution timed out after ${CliController_1.MAX_WAIT_MS / 1000}s`));
+                }, CliController_1.MAX_WAIT_MS);
+            });
+            try {
+                const runResult = await Promise.race([
+                    this.activeExecutions.getPostExecutePromise(executionId),
+                    timeoutPromise,
+                ]);
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+                if (!runResult) {
+                    this.logger.error('[cli] Execution returned no data');
+                    res.json({
+                        success: false,
+                        executionId,
+                        status: 'error',
+                        executionTime: totalTime,
+                        error: 'Execution returned no data',
+                    });
+                    return;
+                }
+                const isSuccess = runResult.status !== 'error' && !runResult.data.resultData?.error;
+                this.logger.info(`[cli] Execution completed in ${totalTime}s — status: ${runResult.status}, success: ${isSuccess}`);
+                const fullExecution = await this.executionRepository.findSingleExecution(executionId, {
+                    includeData: true,
+                    unflattenData: true,
+                });
+                res.json({
+                    success: isSuccess,
+                    executionId,
+                    status: runResult.status,
+                    executionTime: totalTime,
+                    data: fullExecution?.data?.resultData ?? runResult.data.resultData,
+                });
+            }
+            catch (error) {
+                if (timeoutId)
+                    clearTimeout(timeoutId);
+                throw error;
+            }
+        }
+        catch (error) {
+            const totalTime = ((Date.now() - startTime) / 1000).toFixed(1);
+            this.logger.error(`[cli] Error: ${error instanceof Error ? error.message : String(error)}`);
+            res.status(500).json({
+                success: false,
+                executionTime: totalTime,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    async syncWorkflow(fileData, userId) {
+        if (fileData.id && (0, utils_1.isWorkflowIdValid)(fileData.id)) {
+            const existing = await this.workflowRepository.findOneBy({ id: fileData.id });
+            if (existing) {
+                const fileUpdatedAt = fileData.updatedAt
+                    ? new Date(fileData.updatedAt)
+                    : null;
+                const serverUpdatedAt = existing.updatedAt
+                    ? new Date(existing.updatedAt)
+                    : null;
+                if (fileUpdatedAt && serverUpdatedAt && fileUpdatedAt > serverUpdatedAt) {
+                    this.logger.info(`[cli] Updating existing workflow (ID match): ${existing.id}`);
+                    await this.workflowRepository.update(existing.id, {
+                        nodes: fileData.nodes,
+                        connections: fileData.connections,
+                        settings: fileData.settings,
+                        name: fileData.name,
+                        updatedAt: new Date(),
+                    });
+                }
+                else {
+                    this.logger.info(`[cli] Using existing workflow (ID match): ${existing.id}`);
+                }
+                return existing.id;
+            }
+        }
+        if (fileData.name) {
+            const existing = await this.workflowRepository.findOneBy({ name: fileData.name });
+            if (existing) {
+                const fileUpdatedAt = fileData.updatedAt
+                    ? new Date(fileData.updatedAt)
+                    : null;
+                const serverUpdatedAt = existing.updatedAt
+                    ? new Date(existing.updatedAt)
+                    : null;
+                if (fileUpdatedAt && serverUpdatedAt && fileUpdatedAt > serverUpdatedAt) {
+                    this.logger.info(`[cli] Updating existing workflow (name match): ${existing.id}`);
+                    await this.workflowRepository.update(existing.id, {
+                        nodes: fileData.nodes,
+                        connections: fileData.connections,
+                        settings: fileData.settings,
+                        name: fileData.name,
+                        updatedAt: new Date(),
+                    });
+                }
+                else {
+                    this.logger.info(`[cli] Using existing workflow (name match): ${existing.id}`);
+                }
+                return existing.id;
+            }
+        }
+        const workflowId = fileData.id && (0, utils_1.isWorkflowIdValid)(fileData.id) ? fileData.id : (0, db_1.generateNanoId)();
+        fileData.id = workflowId;
+        this.logger.info(`[cli] Creating new workflow: "${fileData.name}" (ID: ${workflowId})`);
+        const { manager: dbManager } = this.workflowRepository;
+        await dbManager.transaction(async (transactionManager) => {
+            const personalProject = await this.projectRepository.getPersonalProjectForUserOrFail(userId, transactionManager);
+            const workflowEntity = this.workflowRepository.create({
+                ...fileData,
+                active: false,
+                isArchived: false,
+                versionId: fileData.versionId || (0, uuid_1.v4)(),
+                createdAt: fileData.createdAt || new Date(),
+                updatedAt: fileData.updatedAt || new Date(),
+            });
+            const savedWorkflow = await transactionManager.save(workflowEntity);
+            const sharedWorkflow = this.sharedWorkflowRepository.create({
+                role: 'workflow:owner',
+                projectId: personalProject.id,
+                workflow: savedWorkflow,
+            });
+            await transactionManager.save(sharedWorkflow);
+        });
+        return workflowId;
+    }
+    async health() {
+        return { status: 'ok', timestamp: new Date().toISOString() };
+    }
+};
+exports.CliController = CliController;
+CliController.MAX_WAIT_MS = 5 * 60 * 1000;
+__decorate([
+    (0, decorators_1.Post)('/run', { skipAuth: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], CliController.prototype, "run", null);
+__decorate([
+    (0, decorators_1.Get)('/health', { skipAuth: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], CliController.prototype, "health", null);
+exports.CliController = CliController = CliController_1 = __decorate([
+    (0, decorators_1.RestController)('/cli'),
+    __metadata("design:paramtypes", [backend_common_1.Logger,
+        db_1.WorkflowRepository,
+        db_1.SharedWorkflowRepository,
+        db_1.ProjectRepository,
+        db_1.ExecutionRepository,
+        ownership_service_1.OwnershipService,
+        active_executions_1.ActiveExecutions,
+        workflow_runner_1.WorkflowRunner])
+], CliController);

package/dist/controllers/users.controller.d.ts

@@ -63,9 +63,9 @@ export declare class UsersController {
             mfaEnabled?: boolean | undefined;
             isOwner?: boolean | undefined;
             projectRelations?: {
+                role: string;
                 id: string;
                 name: string;
-                role: string;
             }[] | null | undefined;
             isPending?: boolean | undefined;
             signInType?: string | undefined;

package/dist/environments.ee/source-control/source-control-status.service.ee.d.ts

@@ -23,10 +23,10 @@ export declare class SourceControlStatusService {
     getStatus(user: User, options: SourceControlGetStatus): Promise<{
         type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
         status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+        file: string;
         id: string;
         name: string;
         updatedAt: string;
-        file: string;
         location: "local" | "remote";
         conflict: boolean;
         pushed?: boolean | undefined;
@@ -63,10 +63,10 @@ export declare class SourceControlStatusService {
         sourceControlledFiles: {
             type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
             status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+            file: string;
             id: string;
             name: string;
             updatedAt: string;
-            file: string;
             location: "local" | "remote";
             conflict: boolean;
             pushed?: boolean | undefined;

package/dist/environments.ee/source-control/source-control.controller.ee.d.ts

@@ -31,10 +31,10 @@ export declare class SourceControlController {
     getStatus(req: SourceControlRequest.GetStatus): Promise<{
         type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
         status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+        file: string;
         id: string;
         name: string;
         updatedAt: string;
-        file: string;
         location: "local" | "remote";
         conflict: boolean;
         pushed?: boolean | undefined;
@@ -71,10 +71,10 @@ export declare class SourceControlController {
         sourceControlledFiles: {
             type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
             status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+            file: string;
             id: string;
             name: string;
             updatedAt: string;
-            file: string;
             location: "local" | "remote";
             conflict: boolean;
             pushed?: boolean | undefined;
@@ -88,10 +88,10 @@ export declare class SourceControlController {
     status(req: SourceControlRequest.GetStatus): Promise<{
         type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
         status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+        file: string;
         id: string;
         name: string;
         updatedAt: string;
-        file: string;
         location: "local" | "remote";
         conflict: boolean;
         pushed?: boolean | undefined;
@@ -128,10 +128,10 @@ export declare class SourceControlController {
         sourceControlledFiles: {
             type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
             status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+            file: string;
             id: string;
             name: string;
             updatedAt: string;
-            file: string;
             location: "local" | "remote";
             conflict: boolean;
             pushed?: boolean | undefined;

package/dist/environments.ee/source-control/source-control.service.ee.d.ts

@@ -57,10 +57,10 @@ export declare class SourceControlService {
     getStatus(user: User, options: SourceControlGetStatus): Promise<{
         type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
         status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+        file: string;
         id: string;
         name: string;
         updatedAt: string;
-        file: string;
         location: "local" | "remote";
         conflict: boolean;
         pushed?: boolean | undefined;
@@ -97,10 +97,10 @@ export declare class SourceControlService {
         sourceControlledFiles: {
             type: "workflow" | "project" | "credential" | "file" | "tags" | "variables" | "folders";
             status: "unknown" | "new" | "modified" | "deleted" | "created" | "renamed" | "conflicted" | "ignored" | "staged";
+            file: string;
             id: string;
             name: string;
             updatedAt: string;
-            file: string;
             location: "local" | "remote";
             conflict: boolean;
             pushed?: boolean | undefined;

package/dist/events/relays/workflow-failure-notification.event-relay.d.ts

@@ -0,0 +1,13 @@
+import { Logger } from '@n8n/backend-common';
+import { UserRepository } from '@n8n/db';
+import { EventService } from '../../events/event.service';
+import { EventRelay } from '../../events/relays/event-relay';
+import { UserManagementMailer } from '../../user-management/email';
+export declare class WorkflowFailureNotificationEventRelay extends EventRelay {
+    private readonly mailer;
+    private readonly userRepository;
+    private readonly logger;
+    constructor(eventService: EventService, mailer: UserManagementMailer, userRepository: UserRepository, logger: Logger);
+    init(): void;
+    private onFirstProductionWorkflowFailed;
+}

package/dist/events/relays/workflow-failure-notification.event-relay.js

@@ -0,0 +1,77 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowFailureNotificationEventRelay = void 0;
+const backend_common_1 = require("@n8n/backend-common");
+const db_1 = require("@n8n/db");
+const di_1 = require("@n8n/di");
+const event_service_1 = require("../../events/event.service");
+const event_relay_1 = require("../../events/relays/event-relay");
+const email_1 = require("../../user-management/email");
+let WorkflowFailureNotificationEventRelay = class WorkflowFailureNotificationEventRelay extends event_relay_1.EventRelay {
+    constructor(eventService, mailer, userRepository, logger) {
+        super(eventService);
+        this.mailer = mailer;
+        this.userRepository = userRepository;
+        this.logger = logger;
+    }
+    init() {
+        this.setupListeners({
+            'instance-first-production-workflow-failed': async (event) => await this.onFirstProductionWorkflowFailed(event),
+        });
+    }
+    async onFirstProductionWorkflowFailed(event) {
+        const { workflowId, workflowName, userId } = event;
+        if (!this.mailer.isEmailSetUp) {
+            this.logger.debug('Skipping first production failure email - SMTP not configured', {
+                workflowId,
+                userId,
+            });
+            return;
+        }
+        try {
+            const user = await this.userRepository.findOneBy({ id: userId });
+            if (!user || !user.email) {
+                this.logger.warn('Cannot send first production failure email - user not found or no email', {
+                    workflowId,
+                    userId,
+                });
+                return;
+            }
+            await this.mailer.workflowFailure({
+                email: user.email,
+                firstName: user.firstName,
+                workflowId,
+                workflowName,
+            });
+            this.logger.info('Sent first production failure email', {
+                workflowId,
+                userId,
+                email: user.email,
+            });
+        }
+        catch (error) {
+            this.logger.error('Failed to send first production failure email', {
+                workflowId,
+                userId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+};
+exports.WorkflowFailureNotificationEventRelay = WorkflowFailureNotificationEventRelay;
+exports.WorkflowFailureNotificationEventRelay = WorkflowFailureNotificationEventRelay = __decorate([
+    (0, di_1.Service)(),
+    __metadata("design:paramtypes", [event_service_1.EventService,
+        email_1.UserManagementMailer,
+        db_1.UserRepository,
+        backend_common_1.Logger])
+], WorkflowFailureNotificationEventRelay);

package/dist/executions/execution-data/types.d.ts

@@ -0,0 +1,17 @@
+import type { IWorkflowBase } from 'n8n-workflow';
+type ExecutionRef = {
+    workflowId: string;
+    executionId: string;
+};
+type ExecutionDataPayload = {
+    data: string;
+    workflowData: IWorkflowBase;
+    workflowVersionId: string | null;
+};
+export interface ExecutionDataManager {
+    init?(): Promise<void>;
+    write(ref: ExecutionRef, payload: ExecutionDataPayload): Promise<void>;
+    read(ref: ExecutionRef): Promise<ExecutionDataPayload>;
+    delete(ref: ExecutionRef | ExecutionRef[]): Promise<void>;
+}
+export {};

package/dist/executions/execution-data/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/executions/failed-run-factory.d.ts

@@ -0,0 +1,4 @@
+import { type ExecutionError, type INode, type IRun, type WorkflowExecuteMode } from 'n8n-workflow';
+export declare class FailedRunFactory {
+    generateFailedExecutionFromError(mode: WorkflowExecuteMode, error: ExecutionError, node: INode | undefined, startTime?: number): IRun;
+}

package/dist/executions/failed-run-factory.js

@@ -0,0 +1,71 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailedRunFactory = void 0;
+const di_1 = require("@n8n/di");
+const n8n_workflow_1 = require("n8n-workflow");
+let FailedRunFactory = class FailedRunFactory {
+    generateFailedExecutionFromError(mode, error, node, startTime = Date.now()) {
+        const executionError = {
+            ...error,
+            message: error.message,
+            stack: error.stack,
+        };
+        const returnData = {
+            data: (0, n8n_workflow_1.createRunExecutionData)({
+                resultData: {
+                    error: executionError,
+                    runData: {},
+                },
+            }),
+            finished: false,
+            mode,
+            startedAt: new Date(),
+            stoppedAt: new Date(),
+            status: 'error',
+        };
+        if (node) {
+            returnData.data.startData = {
+                destinationNode: {
+                    nodeName: node.name,
+                    mode: 'inclusive',
+                },
+                runNodeFilter: [node.name],
+            };
+            returnData.data.resultData.lastNodeExecuted = node.name;
+            returnData.data.resultData.runData[node.name] = [
+                {
+                    startTime,
+                    executionIndex: 0,
+                    executionTime: 0,
+                    executionStatus: 'error',
+                    error: executionError,
+                    source: [],
+                },
+            ];
+            returnData.data.executionData = {
+                contextData: {},
+                metadata: {},
+                waitingExecution: {},
+                waitingExecutionSource: {},
+                nodeExecutionStack: [
+                    {
+                        node,
+                        data: {},
+                        source: null,
+                    },
+                ],
+            };
+        }
+        return returnData;
+    }
+};
+exports.FailedRunFactory = FailedRunFactory;
+exports.FailedRunFactory = FailedRunFactory = __decorate([
+    (0, di_1.Service)()
+], FailedRunFactory);

package/dist/index.d.ts

@@ -1 +1,2 @@
-export {};
+export { default } from './node-lib';
+export { run, type N8nRunOptions } from './node-lib';

package/dist/index.js

@@ -1,2 +1,10 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.default = void 0;
+var node_lib_1 = require("./node-lib");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(node_lib_1).default; } });
+var node_lib_2 = require("./node-lib");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return node_lib_2.run; } });

package/dist/interfaces.d.ts

@@ -7,7 +7,7 @@ import type { ActiveWorkflowManager } from './active-workflow-manager';
 import type { ExternalHooks } from './external-hooks';
 import type WebSocket from 'ws';
 export interface ExtendedWebSocket extends WebSocket {
-    isAlive?: boolean;
+    isAlive: boolean;
 }
 export interface ICredentialsTypeData {
     [key: string]: CredentialLoadingDetails;