@atom8n/n8n 2.4.7 → 2.5.1

package/dist/chat/chat-service.types.d.ts

@@ -29,30 +29,30 @@ export declare const chatMessageSchema: z.ZodObject<{
         type: z.ZodString;
         data: z.ZodString;
     }, "strip", z.ZodTypeAny, {
-        data: string;
         name: string;
+        data: string;
         type: string;
     }, {
-        data: string;
         name: string;
+        data: string;
         type: string;
     }>, "many">>;
 }, "strip", z.ZodTypeAny, {
+    chatInput: string;
     action: "sendMessage";
     sessionId: string;
-    chatInput: string;
     files?: {
-        data: string;
         name: string;
+        data: string;
         type: string;
     }[] | undefined;
 }, {
+    chatInput: string;
     action: "sendMessage";
     sessionId: string;
-    chatInput: string;
     files?: {
-        data: string;
         name: string;
+        data: string;
         type: string;
     }[] | undefined;
 }>;

package/dist/commands/execute-batch.d.ts

@@ -20,8 +20,8 @@ declare const flagsSchema: z.ZodObject<{
     concurrency: number;
     retries: number;
     output?: string | undefined;
-    ids?: string | undefined;
     compare?: string | undefined;
+    ids?: string | undefined;
     snapshot?: string | undefined;
     shallow?: boolean | undefined;
     githubWorkflow?: boolean | undefined;
@@ -31,8 +31,8 @@ declare const flagsSchema: z.ZodObject<{
     debug?: boolean | undefined;
     output?: string | undefined;
     concurrency?: number | undefined;
-    ids?: string | undefined;
     compare?: string | undefined;
+    ids?: string | undefined;
     snapshot?: string | undefined;
     shallow?: boolean | undefined;
     githubWorkflow?: boolean | undefined;

package/dist/commands/import/credentials.d.ts

@@ -8,12 +8,12 @@ declare const flagsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     separate: boolean;
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
 }, {
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     separate?: boolean | undefined;
 }>;
 export declare class ImportCredentialsCommand extends BaseCommand<z.infer<typeof flagsSchema>> {

package/dist/commands/import/workflow.d.ts

@@ -8,12 +8,12 @@ declare const flagsSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     separate: boolean;
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
 }, {
     input?: string | undefined;
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     separate?: boolean | undefined;
 }>;
 export declare class ImportWorkflowsCommand extends BaseCommand<z.infer<typeof flagsSchema>> {

package/dist/commands/ldap/reset.d.ts

@@ -5,12 +5,12 @@ declare const flagsSchema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     deleteWorkflowsAndCredentials: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     deleteWorkflowsAndCredentials?: boolean | undefined;
 }, {
-    userId?: string | undefined;
     projectId?: string | undefined;
+    userId?: string | undefined;
     deleteWorkflowsAndCredentials?: boolean | undefined;
 }>;
 export declare class Reset extends BaseCommand<z.infer<typeof flagsSchema>> {

package/dist/commands/mcp.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { BaseCommand } from './base-command';
+declare const flagsSchema: z.ZodObject<{
+    file: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    file?: string | undefined;
+}, {
+    file?: string | undefined;
+}>;
+export declare class Mcp extends BaseCommand<z.infer<typeof flagsSchema>> {
+    needsCommunityPackages: boolean;
+    needsTaskRunner: boolean;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    private executeWorkflowTool;
+    private resolveAllFiles;
+    private resolvePositionalFiles;
+    private logStderr;
+    private sanitizeToolName;
+    catch(error: Error): Promise<void>;
+    finally(error: Error | undefined): Promise<void>;
+}
+export {};

package/dist/commands/mcp.js

@@ -0,0 +1,315 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Mcp = void 0;
+const decorators_1 = require("@n8n/decorators");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const n8n_workflow_1 = require("n8n-workflow");
+const zod_1 = require("zod");
+const base_command_1 = require("./base-command");
+const flagsSchema = zod_1.z.object({
+    file: zod_1.z.string().describe('Path to the .n8n workflow file to expose as an MCP tool').optional(),
+});
+let Mcp = class Mcp extends base_command_1.BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.needsCommunityPackages = false;
+        this.needsTaskRunner = false;
+    }
+    async init() {
+        await super.init();
+    }
+    async run() {
+        const { flags } = this;
+        const filePaths = this.resolveAllFiles(flags.file);
+        this.logStderr(`[mcp] Resolved ${filePaths.length} workflow file(s)`);
+        if (filePaths.length === 0) {
+            throw new n8n_workflow_1.UserError('No workflow file specified. Usage: n8n mcp <file.n8n> [file2.n8n ...] or n8n mcp --file=<file.n8n>');
+        }
+        this.logStderr(`[mcp] ── STARTING MCP SERVER ──`);
+        const workflows = [];
+        for (const fileArg of filePaths) {
+            const filePath = path_1.default.resolve(fileArg);
+            this.logStderr(`[mcp] Loading: ${filePath}`);
+            if (!fs_1.default.existsSync(filePath)) {
+                throw new n8n_workflow_1.UserError(`[mcp] The workflow file does not exist: ${filePath}`);
+            }
+            try {
+                const fileContent = fs_1.default.readFileSync(filePath, { encoding: 'utf8' });
+                const workflowData = (0, n8n_workflow_1.jsonParse)(fileContent);
+                this.logStderr(`[mcp]   ✓ "${workflowData.name}" (${workflowData.nodes?.length ?? 0} nodes)`);
+                workflows.push({ filePath, data: workflowData });
+            }
+            catch (error) {
+                throw new n8n_workflow_1.UserError(`[mcp] Failed to parse ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.logStderr(`[mcp] Loaded ${workflows.length} workflow(s)`);
+        this.logStderr(`[mcp] Creating MCP server...`);
+        const { McpServer } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/mcp.js')));
+        const { StdioServerTransport } = await Promise.resolve().then(() => __importStar(require('@modelcontextprotocol/sdk/server/stdio.js')));
+        const serverPort = this.globalConfig.port;
+        const serverUrl = `http://localhost:${serverPort}`;
+        this.logStderr(`[mcp] n8n server URL: ${serverUrl}`);
+        const serverName = workflows.length === 1
+            ? workflows[0].data.name ||
+                this.sanitizeToolName(path_1.default.basename(workflows[0].filePath, '.n8n'))
+            : 'n8n MCP Server';
+        const server = new McpServer({
+            name: serverName,
+            version: '1.0.0',
+        });
+        const usedToolNames = new Set();
+        for (const { filePath, data: workflowData } of workflows) {
+            let toolName = this.sanitizeToolName(workflowData.name || path_1.default.basename(filePath, '.n8n'));
+            if (usedToolNames.has(toolName)) {
+                let suffix = 2;
+                while (usedToolNames.has(`${toolName}_${suffix}`))
+                    suffix++;
+                toolName = `${toolName}_${suffix}`;
+            }
+            usedToolNames.add(toolName);
+            const triggerNode = workflowData.nodes?.find((node) => node.type.toLowerCase().includes('trigger') ||
+                node.type.toLowerCase().includes('webhook') ||
+                node.type === 'n8n-nodes-base.start');
+            const triggerType = triggerNode?.type ?? 'unknown';
+            const isChatTrigger = triggerType === '@n8n/n8n-nodes-langchain.chatTrigger';
+            this.logStderr(`[mcp] Registering tool "${toolName}" (trigger: ${triggerType})`);
+            const inputSchemaShape = isChatTrigger
+                ? { input: zod_1.z.string().describe('Input text for the chat workflow') }
+                : { input: zod_1.z.string().optional().describe('Input text or data for the workflow') };
+            const wfData = workflowData;
+            const wfIsChatTrigger = isChatTrigger;
+            const wfToolName = toolName;
+            server.registerTool(toolName, {
+                description: `Execute the n8n workflow "${workflowData.name}". ${isChatTrigger
+                    ? 'This is a chat-based workflow — provide input text.'
+                    : 'Provide optional input text for the workflow trigger.'}`,
+                inputSchema: inputSchemaShape,
+            }, async (args) => {
+                return await this.executeWorkflowTool(wfToolName, wfData, wfIsChatTrigger, serverUrl, args);
+            });
+        }
+        this.logStderr(`[mcp] Registered ${usedToolNames.size} tool(s): ${[...usedToolNames].join(', ')}`);
+        this.logStderr(`[mcp] Connecting via stdio transport...`);
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+        this.logStderr(`[mcp] ✅ MCP server is running. Waiting for requests on stdin...`);
+        await new Promise((resolve) => {
+            process.stdin.on('end', () => {
+                this.logStderr(`[mcp] stdin closed. Shutting down.`);
+                resolve();
+            });
+            process.stdin.on('close', () => {
+                this.logStderr(`[mcp] stdin closed. Shutting down.`);
+                resolve();
+            });
+        });
+        this.logStderr(`[mcp] Server stopped.`);
+    }
+    async executeWorkflowTool(toolName, workflowData, isChatTrigger, serverUrl, args) {
+        this.logStderr(`[mcp] ── TOOL CALL: "${toolName}" ──`);
+        this.logStderr(`[mcp] Input: ${JSON.stringify(args)}`);
+        try {
+            this.logStderr(`[mcp] Checking server health at ${serverUrl}...`);
+            const healthResponse = await fetch(`${serverUrl}/rest/cli/health`);
+            if (!healthResponse.ok) {
+                throw new Error(`Health check returned ${healthResponse.status}`);
+            }
+            this.logStderr(`[mcp] Server is reachable.`);
+            const executeUrl = `${serverUrl}/rest/cli/run`;
+            this.logStderr(`[mcp] POST ${executeUrl}`);
+            const requestBody = { workflowData };
+            if (args.input !== undefined) {
+                if (isChatTrigger) {
+                    requestBody.chatInput = String(args.input);
+                }
+                else {
+                    try {
+                        const parsed = JSON.parse(String(args.input));
+                        if (typeof parsed === 'object' && parsed !== null) {
+                            requestBody.inputData = parsed;
+                        }
+                        else {
+                            requestBody.chatInput = String(args.input);
+                        }
+                    }
+                    catch {
+                        requestBody.chatInput = String(args.input);
+                    }
+                }
+            }
+            const response = await fetch(executeUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(requestBody),
+            });
+            this.logStderr(`[mcp] Response status: ${response.status} ${response.statusText}`);
+            if (!response.ok) {
+                const errorBody = await response.text();
+                this.logStderr(`[mcp] API error: ${errorBody}`);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Error executing workflow: ${response.status} ${response.statusText} — ${errorBody}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const result = (await response.json());
+            this.logStderr(`[mcp] Execution complete — success: ${result.success}, executionId: ${result.executionId ?? 'unknown'}, time: ${result.executionTime ?? '?'}s`);
+            const lastNodeName = result.data?.lastNodeExecuted;
+            const outputItems = [];
+            if (lastNodeName && result.data?.runData?.[lastNodeName]) {
+                const nodeRuns = result.data.runData[lastNodeName];
+                const lastRun = nodeRuns[nodeRuns.length - 1];
+                if (lastRun?.data?.main) {
+                    for (const branch of lastRun.data.main) {
+                        if (branch) {
+                            for (const item of branch) {
+                                outputItems.push(item.json);
+                            }
+                        }
+                    }
+                }
+            }
+            this.logStderr(`[mcp] Output items: ${outputItems.length}`);
+            if (!result.success) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Workflow execution failed: ${result.error ?? JSON.stringify(result.data?.error ?? 'Unknown error')}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify(outputItems.length === 1 ? outputItems[0] : outputItems, null, 2),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            const errorMsg = error instanceof Error ? error.message : String(error);
+            this.logStderr(`[mcp] Error: ${errorMsg}`);
+            return {
+                content: [{ type: 'text', text: `Error: ${errorMsg}` }],
+                isError: true,
+            };
+        }
+    }
+    resolveAllFiles(flagFile) {
+        const files = [];
+        if (flagFile) {
+            this.logStderr(`[mcp] From --file flag: "${flagFile}"`);
+            files.push(flagFile);
+        }
+        const positionalFiles = this.resolvePositionalFiles();
+        for (const f of positionalFiles) {
+            if (!files.includes(f)) {
+                files.push(f);
+            }
+        }
+        return files;
+    }
+    resolvePositionalFiles() {
+        const argv = process.argv;
+        const mcpIndex = argv.indexOf('mcp');
+        if (mcpIndex === -1)
+            return [];
+        const files = [];
+        for (let i = mcpIndex + 1; i < argv.length; i++) {
+            const arg = argv[i];
+            if (!arg.startsWith('--') && !arg.startsWith('-')) {
+                this.logStderr(`[mcp] Found positional file argument: "${arg}"`);
+                files.push(arg);
+            }
+        }
+        return files;
+    }
+    logStderr(message) {
+        process.stderr.write(`${message}\n`);
+    }
+    sanitizeToolName(name) {
+        return (name
+            .toLowerCase()
+            .replace(/[^a-z0-9_-]/g, '_')
+            .replace(/_+/g, '_')
+            .replace(/^_|_$/g, '') || 'n8n_workflow');
+    }
+    async catch(error) {
+        this.logStderr(`[mcp] Fatal error: ${error.message}`);
+        if (error.stack)
+            this.logStderr(`[mcp] ${error.stack}`);
+    }
+    async finally(error) {
+        if (error) {
+            await super.finally(error);
+        }
+    }
+};
+exports.Mcp = Mcp;
+exports.Mcp = Mcp = __decorate([
+    (0, decorators_1.Command)({
+        name: 'mcp',
+        description: 'Starts an MCP (Model Context Protocol) server over stdio, exposing one or more .n8n ' +
+            'workflow files as callable tools. The server reads JSON-RPC from stdin and writes to stdout. ' +
+            'Designed to be used as an MCP server command in MCP client configurations.',
+        examples: [
+            'workflow.n8n',
+            'workflow1.n8n workflow2.n8n workflow3.n8n',
+            '--file=workflow.n8n',
+            '/path/to/*.n8n',
+        ],
+        flagsSchema,
+    })
+], Mcp);

package/dist/commands/run.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { BaseCommand } from './base-command';
+declare const flagsSchema: z.ZodObject<{
+    file: z.ZodString;
+    rawOutput: z.ZodOptional<z.ZodBoolean>;
+    input: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    file: string;
+    input?: string | undefined;
+    rawOutput?: boolean | undefined;
+}, {
+    file: string;
+    input?: string | undefined;
+    rawOutput?: boolean | undefined;
+}>;
+export declare class Run extends BaseCommand<z.infer<typeof flagsSchema>> {
+    needsCommunityPackages: boolean;
+    needsTaskRunner: boolean;
+    init(): Promise<void>;
+    run(): Promise<void>;
+    catch(error: Error): Promise<void>;
+}
+export {};

package/dist/commands/run.js

@@ -0,0 +1,162 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Run = void 0;
+const decorators_1 = require("@n8n/decorators");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const n8n_workflow_1 = require("n8n-workflow");
+const zod_1 = require("zod");
+const base_command_1 = require("./base-command");
+const flagsSchema = zod_1.z.object({
+    file: zod_1.z.string().describe('Path to the .n8n workflow file to run'),
+    rawOutput: zod_1.z.boolean().describe('Outputs only JSON data, with no other text').optional(),
+    input: zod_1.z.string().describe('Input text for chat/webhook trigger workflows').optional(),
+});
+let Run = class Run extends base_command_1.BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.needsCommunityPackages = false;
+        this.needsTaskRunner = false;
+    }
+    async init() {
+        await super.init();
+    }
+    async run() {
+        const { flags } = this;
+        if (!flags.file) {
+            throw new n8n_workflow_1.UserError('The --file flag is required. Please provide a path to the .n8n workflow file.');
+        }
+        const filePath = path_1.default.resolve(flags.file);
+        this.logger.info(`[run] ── READING FILE ──`);
+        this.logger.info(`[run] File path: ${filePath}`);
+        if (!fs_1.default.existsSync(filePath)) {
+            throw new n8n_workflow_1.UserError(`[run] The workflow file does not exist: ${filePath}`);
+        }
+        const fileStat = fs_1.default.statSync(filePath);
+        this.logger.info(`[run] File size: ${fileStat.size} bytes, Last modified: ${fileStat.mtime.toISOString()}`);
+        let fileData;
+        try {
+            const fileContent = fs_1.default.readFileSync(filePath, { encoding: 'utf8' });
+            fileData = (0, n8n_workflow_1.jsonParse)(fileContent);
+            this.logger.info(`[run] Successfully parsed workflow file.`);
+            this.logger.info(`[run]   Name: "${fileData.name}"`);
+            this.logger.info(`[run]   ID: "${fileData.id ?? 'none'}"`);
+            this.logger.info(`[run]   Nodes (${fileData.nodes?.length ?? 0}):`);
+            if (fileData.nodes && Array.isArray(fileData.nodes)) {
+                for (const node of fileData.nodes) {
+                    this.logger.info(`[run]     - "${node.name}" (type: ${node.type}, version: ${node.typeVersion})`);
+                }
+            }
+        }
+        catch (error) {
+            throw new n8n_workflow_1.UserError(`[run] Failed to parse workflow file: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const serverPort = this.globalConfig.port;
+        const serverUrl = `http://localhost:${serverPort}`;
+        this.logger.info(`[run] ── EXECUTING ──`);
+        this.logger.info(`[run] n8n server URL: ${serverUrl}`);
+        try {
+            const healthResponse = await fetch(`${serverUrl}/rest/cli/health`);
+            if (!healthResponse.ok) {
+                throw new Error(`Health check returned ${healthResponse.status}`);
+            }
+            this.logger.info(`[run] Server is reachable.`);
+        }
+        catch (error) {
+            throw new n8n_workflow_1.UserError(`[run] Cannot reach n8n server at ${serverUrl}. Is the server running? Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        const executeUrl = `${serverUrl}/rest/cli/run`;
+        this.logger.info(`[run] POST ${executeUrl}`);
+        const response = await fetch(executeUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                workflowData: fileData,
+                chatInput: flags.input,
+            }),
+        });
+        this.logger.info(`[run] Response status: ${response.status} ${response.statusText}`);
+        if (!response.ok) {
+            const errorBody = await response.text();
+            this.logger.error(`[run] API error response: ${errorBody}`);
+            throw new n8n_workflow_1.UserError(`[run] Failed to execute workflow: ${response.status} ${response.statusText} — ${errorBody}`);
+        }
+        const result = (await response.json());
+        this.logger.info(`[run] ── RESULTS ──`);
+        this.logger.info(`[run] Execution ID: ${result.executionId ?? 'unknown'}, Status: ${result.status ?? 'unknown'}, Time: ${result.executionTime ?? '?'}s`);
+        if (result.success) {
+            if (flags.rawOutput === undefined) {
+                this.logger.info('[run] ✅ Execution was successful!');
+                this.logger.info('====================================');
+            }
+        }
+        else {
+            this.logger.error(`[run] ❌ Execution FAILED`);
+            this.logger.error('====================================');
+            if (result.error) {
+                this.logger.error(`[run] Error: ${result.error}`);
+            }
+        }
+        if (result.data?.runData) {
+            const runData = result.data.runData;
+            const nodeNames = Object.keys(runData);
+            this.logger.info(`[run] Nodes executed (${nodeNames.length}): ${nodeNames.join(' → ')}`);
+            for (const [nodeName, nodeRuns] of Object.entries(runData)) {
+                for (const nodeRun of nodeRuns) {
+                    const status = nodeRun.executionStatus ?? 'unknown';
+                    const time = nodeRun.executionTime ?? 0;
+                    this.logger.info(`[run]   ✅ "${nodeName}" — status: ${status}, time: ${time}ms`);
+                    if (nodeRun.data?.main) {
+                        for (const outputBranch of nodeRun.data.main) {
+                            if (outputBranch) {
+                                this.logger.info(`[run]     Output items: ${outputBranch.length}`);
+                                for (const item of outputBranch) {
+                                    if (item.json) {
+                                        this.logger.info(`[run]     → ${JSON.stringify(item.json)}`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        this.log(JSON.stringify(result, null, 2));
+        this.logger.info(`[run] Done.`);
+    }
+    async catch(error) {
+        this.logger.error('[run] Error executing workflow. See log messages for details.');
+        this.logger.error('[run] Execution error:');
+        this.logger.info('====================================');
+        this.logger.error(error.message);
+        if (error instanceof n8n_workflow_1.ExecutionBaseError)
+            this.logger.error(error.description);
+        if (error.stack)
+            this.logger.error(error.stack);
+    }
+};
+exports.Run = Run;
+exports.Run = Run = __decorate([
+    (0, decorators_1.Command)({
+        name: 'run',
+        description: 'Syncs a .n8n workflow file to the server and executes it synchronously. ' +
+            'Returns the full execution result including per-node outputs.',
+        examples: [
+            '--file=workflow.n8n',
+            '--file=/path/to/workflow.n8n --input="Hello"',
+            '--file=workflow.n8n --rawOutput',
+        ],
+        flagsSchema,
+    })
+], Run);

package/dist/controllers/annotation-tags.controller.ee.d.ts

@@ -4,8 +4,8 @@ export declare class AnnotationTagsController {
     private readonly annotationTagService;
     constructor(annotationTagService: AnnotationTagService);
     getAll(req: AnnotationTagsRequest.GetAll): Promise<{
-        id: string;
         name: string;
+        id: string;
         createdAt: Date;
         updatedAt: Date;
     }[]>;

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

@@ -0,0 +1,26 @@
+import { Logger } from '@n8n/backend-common';
+import { WorkflowRepository, SharedWorkflowRepository, ProjectRepository, ExecutionRepository } from '@n8n/db';
+import type { Request, Response } from 'express';
+import { ActiveExecutions } from '../active-executions';
+import { OwnershipService } from '../services/ownership.service';
+import { WorkflowRunner } from '../workflow-runner';
+export declare class CliController {
+    private readonly logger;
+    private readonly workflowRepository;
+    private readonly sharedWorkflowRepository;
+    private readonly projectRepository;
+    private readonly executionRepository;
+    private readonly ownershipService;
+    private readonly activeExecutions;
+    private readonly workflowRunner;
+    private static readonly MAX_WAIT_MS;
+    constructor(logger: Logger, workflowRepository: WorkflowRepository, sharedWorkflowRepository: SharedWorkflowRepository, projectRepository: ProjectRepository, executionRepository: ExecutionRepository, ownershipService: OwnershipService, activeExecutions: ActiveExecutions, workflowRunner: WorkflowRunner);
+    private isWebhookBasedTrigger;
+    private isLocalRequest;
+    run(req: Request, res: Response): Promise<void>;
+    private syncWorkflow;
+    health(): Promise<{
+        status: string;
+        timestamp: string;
+    }>;
+}