@atom8n/n8n 2.5.0 → 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/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/modules/mcp/tools/execute-workflow.tool.d.ts

@@ -12,11 +12,11 @@ declare const inputSchema: z.ZodObject<{
         type: z.ZodLiteral<"chat">;
         chatInput: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        type: "chat";
         chatInput: string;
-    }, {
         type: "chat";
+    }, {
         chatInput: string;
+        type: "chat";
     }>, z.ZodObject<{
         type: z.ZodLiteral<"form">;
         formData: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -34,20 +34,20 @@ declare const inputSchema: z.ZodObject<{
             body: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, "strip", z.ZodTypeAny, {
-            method: "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+            method: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT";
             body?: Record<string, unknown> | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         }, {
+            method?: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT" | undefined;
             body?: Record<string, unknown> | undefined;
-            method?: "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         }>;
     }, "strip", z.ZodTypeAny, {
         type: "webhook";
         webhookData: {
-            method: "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+            method: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT";
             body?: Record<string, unknown> | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
@@ -55,8 +55,8 @@ declare const inputSchema: z.ZodObject<{
     }, {
         type: "webhook";
         webhookData: {
+            method?: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT" | undefined;
             body?: Record<string, unknown> | undefined;
-            method?: "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         };
@@ -64,15 +64,15 @@ declare const inputSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     workflowId: string;
     inputs?: {
-        type: "chat";
         chatInput: string;
+        type: "chat";
     } | {
         type: "form";
         formData: Record<string, unknown>;
     } | {
         type: "webhook";
         webhookData: {
-            method: "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT";
+            method: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT";
             body?: Record<string, unknown> | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
@@ -81,16 +81,16 @@ declare const inputSchema: z.ZodObject<{
 }, {
     workflowId: string;
     inputs?: {
-        type: "chat";
         chatInput: string;
+        type: "chat";
     } | {
         type: "form";
         formData: Record<string, unknown>;
     } | {
         type: "webhook";
         webhookData: {
+            method?: "POST" | "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "PUT" | undefined;
             body?: Record<string, unknown> | undefined;
-            method?: "OPTIONS" | "DELETE" | "GET" | "HEAD" | "PATCH" | "POST" | "PUT" | undefined;
             query?: Record<string, string> | undefined;
             headers?: Record<string, string> | undefined;
         };

package/dist/modules/mcp/tools/schemas.d.ts

@@ -129,20 +129,20 @@ export declare const workflowDetailsOutputSchema: z.ZodObject<{
     triggerInfo: z.ZodString;
 }, "strip", z.ZodTypeAny, {
     workflow: {
+        name: string | null;
+        nodes: z.objectOutputType<{
+            name: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
         tags: z.objectOutputType<{
             id: z.ZodString;
             name: z.ZodString;
         }, z.ZodTypeAny, "passthrough">[];
         id: string;
-        name: string | null;
         active: boolean;
         versionId: string;
         createdAt: string | null;
         updatedAt: string | null;
-        nodes: z.objectOutputType<{
-            name: z.ZodString;
-            type: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">[];
         connections: Record<string, unknown>;
         isArchived: boolean;
         parentFolderId: string | null;
@@ -156,20 +156,20 @@ export declare const workflowDetailsOutputSchema: z.ZodObject<{
     triggerInfo: string;
 }, {
     workflow: {
+        name: string | null;
+        nodes: z.objectInputType<{
+            name: z.ZodString;
+            type: z.ZodString;
+        }, z.ZodTypeAny, "passthrough">[];
         tags: z.objectInputType<{
             id: z.ZodString;
             name: z.ZodString;
         }, z.ZodTypeAny, "passthrough">[];
         id: string;
-        name: string | null;
         active: boolean;
         versionId: string;
         createdAt: string | null;
         updatedAt: string | null;
-        nodes: z.objectInputType<{
-            name: z.ZodString;
-            type: z.ZodString;
-        }, z.ZodTypeAny, "passthrough">[];
         connections: Record<string, unknown>;
         isArchived: boolean;
         parentFolderId: string | null;

package/dist/node-lib.d.ts

@@ -0,0 +1,10 @@
+interface N8nRunOptions {
+    port?: number;
+    baseUrl?: string;
+}
+declare function run(filePath: string, input?: string | Record<string, unknown>, debug?: boolean, options?: N8nRunOptions): Promise<unknown[]>;
+declare const n8n: {
+    run: typeof run;
+};
+export default n8n;
+export { run, type N8nRunOptions };