@atom8n/n8n 2.4.7 → 2.5.1

package/dist/modules/sso-saml/sso-saml.module.js

@@ -0,0 +1,55 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SamlModule = void 0;
+const decorators_1 = require("@n8n/decorators");
+const di_1 = require("@n8n/di");
+let SamlModule = class SamlModule {
+    async init() {
+        await Promise.resolve().then(() => __importStar(require('./saml.controller.ee')));
+        const { SamlService } = await Promise.resolve().then(() => __importStar(require('./saml.service.ee')));
+        await di_1.Container.get(SamlService).init();
+    }
+};
+exports.SamlModule = SamlModule;
+exports.SamlModule = SamlModule = __decorate([
+    (0, decorators_1.BackendModule)({ name: 'sso-saml', licenseFlag: 'feat:saml', instanceTypes: ['main'] })
+], SamlModule);

package/dist/modules/sso-saml/types.d.ts

@@ -0,0 +1,4 @@
+import type { SamlPreferences, SamlPreferencesAttributeMapping } from '@n8n/api-types';
+export type SamlLoginBinding = SamlPreferences['loginBinding'];
+export type SamlAttributeMapping = NonNullable<SamlPreferencesAttributeMapping>;
+export type SamlUserAttributes = SamlAttributeMapping;

package/dist/modules/sso-saml/types.js

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

package/dist/modules/sso-saml/views/init-sso-post.d.ts

@@ -0,0 +1,2 @@
+import type { PostBindingContext } from 'samlify/types/src/entity';
+export declare function getInitSSOFormView(context: PostBindingContext): string;

package/dist/modules/sso-saml/views/init-sso-post.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInitSSOFormView = getInitSSOFormView;
+function getInitSSOFormView(context) {
+    return `
+	<form id="saml-form" method="post" action="${context.entityEndpoint}" autocomplete="off">
+    <input type="hidden" name="${context.type}" value="${context.context}" />
+    ${context.relayState ? '<input type="hidden" name="RelayState" value="{{relayState}}" />' : ''}
+</form>
+<script type="text/javascript">
+    // Automatic form submission
+    (function(){
+        document.forms[0].submit();
+    })();
+</script>`;
+}

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 };

package/dist/node-lib.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const LOG_PREFIX = '[n8n-lib]';
+async function run(filePath, input, debug = false, options) {
+    const log = (...args) => {
+        if (debug)
+            console.log(LOG_PREFIX, ...args);
+    };
+    const logError = (...args) => {
+        if (debug)
+            console.error(LOG_PREFIX, ...args);
+    };
+    const logWarn = (...args) => {
+        if (debug)
+            console.warn(LOG_PREFIX, ...args);
+    };
+    log('── RUN START ──');
+    log(`filePath: "${filePath}"`);
+    log(`input: ${input !== undefined ? JSON.stringify(input) : '(none)'}`);
+    const resolvedPath = path_1.default.resolve(filePath);
+    log(`Resolved path: "${resolvedPath}"`);
+    if (!fs_1.default.existsSync(resolvedPath)) {
+        const errorMsg = `Workflow file does not exist: ${resolvedPath}`;
+        logError(`ERROR: ${errorMsg}`);
+        throw new Error(errorMsg);
+    }
+    let workflowData;
+    try {
+        const fileContent = fs_1.default.readFileSync(resolvedPath, { encoding: 'utf8' });
+        workflowData = JSON.parse(fileContent);
+        log('Successfully parsed workflow file');
+        log(`  Name: "${workflowData.name}"`);
+        log(`  Nodes: ${Array.isArray(workflowData.nodes) ? workflowData.nodes.length : 0}`);
+    }
+    catch (error) {
+        const errorMsg = `Failed to parse workflow file: ${error instanceof Error ? error.message : String(error)}`;
+        logError(`ERROR: ${errorMsg}`);
+        throw new Error(errorMsg);
+    }
+    let serverUrl;
+    if (options?.baseUrl) {
+        serverUrl = options.baseUrl.replace(/\/+$/, '');
+        log(`Using provided baseUrl: "${serverUrl}"`);
+    }
+    else {
+        const port = options?.port ?? parseInt(process.env.N8N_PORT ?? '5888', 10);
+        serverUrl = `http://localhost:${port}`;
+        log(`Using server URL: "${serverUrl}" (port: ${port})`);
+    }
+    const healthUrl = `${serverUrl}/rest/cli/health`;
+    log(`Health check: GET ${healthUrl}`);
+    try {
+        const healthResponse = await fetch(healthUrl);
+        if (!healthResponse.ok) {
+            throw new Error(`Health check returned status ${healthResponse.status}`);
+        }
+        log('Server is reachable');
+    }
+    catch (error) {
+        const errorMsg = `Cannot reach n8n server at ${serverUrl}. Is the server running? Error: ${error instanceof Error ? error.message : String(error)}`;
+        logError(`ERROR: ${errorMsg}`);
+        throw new Error(errorMsg);
+    }
+    const runUrl = `${serverUrl}/rest/cli/run`;
+    log(`Executing workflow: POST ${runUrl}`);
+    const requestBody = { workflowData };
+    if (input !== undefined) {
+        if (typeof input === 'string') {
+            requestBody.chatInput = input;
+        }
+        else {
+            requestBody.inputData = input;
+        }
+    }
+    log(`Request body keys: ${Object.keys(requestBody).join(', ')}`);
+    let response;
+    try {
+        response = await fetch(runUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody),
+        });
+        log(`Response status: ${response.status} ${response.statusText}`);
+    }
+    catch (error) {
+        const errorMsg = `Failed to call n8n API: ${error instanceof Error ? error.message : String(error)}`;
+        logError(`ERROR: ${errorMsg}`);
+        throw new Error(errorMsg);
+    }
+    if (!response.ok) {
+        const errorBody = await response.text();
+        const errorMsg = `API error: ${response.status} ${response.statusText} — ${errorBody}`;
+        logError(`ERROR: ${errorMsg}`);
+        throw new Error(errorMsg);
+    }
+    const apiResult = (await response.json());
+    log('── RESULT ──');
+    log(`Success: ${apiResult.success}`);
+    log(`Execution ID: ${apiResult.executionId ?? 'unknown'}`);
+    log(`Status: ${apiResult.status ?? 'unknown'}`);
+    log(`Execution time: ${apiResult.executionTime ?? '?'}s`);
+    if (!apiResult.success) {
+        const errorMsg = apiResult.error ?? 'Workflow execution failed';
+        logError(`Execution error: ${errorMsg}`);
+        throw new Error(String(errorMsg));
+    }
+    const lastNodeName = apiResult.data?.lastNodeExecuted;
+    log(`Last node executed: "${lastNodeName ?? 'unknown'}"`);
+    if (!lastNodeName || !apiResult.data?.runData?.[lastNodeName]) {
+        logWarn('No output data found for last node');
+        log('── RUN END ──');
+        return [];
+    }
+    const lastNodeRuns = apiResult.data.runData[lastNodeName];
+    const lastRun = lastNodeRuns[lastNodeRuns.length - 1];
+    const outputItems = [];
+    if (lastRun?.data?.main) {
+        for (const branch of lastRun.data.main) {
+            if (branch) {
+                for (const item of branch) {
+                    outputItems.push(item.json);
+                }
+            }
+        }
+    }
+    log(`Output items: ${outputItems.length}`);
+    log('── RUN END ──');
+    return outputItems;
+}
+const n8n = { run };
+exports.default = n8n;

package/dist/push/index.d.ts

@@ -25,7 +25,7 @@ export declare class Push extends TypedEmitter<PushEvents> {
     isBidirectional: boolean;
     private backend;
     constructor(config: PushConfig, instanceSettings: InstanceSettings, logger: Logger, authService: AuthService, publisher: Publisher);
-    getBackend(): SSEPush | WebSocketPush;
+    getBackend(): WebSocketPush | SSEPush;
     setupPushServer(restEndpoint: string, server: Server, app: Application): void;
     setupPushHandler(restEndpoint: string, app: Application): void;
     handleRequest(req: SSEPushRequest | WebSocketPushRequest, res: PushResponse): void;

package/dist/server.d.ts

@@ -26,6 +26,7 @@ import './controllers/users.controller';
 import './controllers/user-settings.controller';
 import './controllers/workflow-statistics.controller';
 import './controllers/api-keys.controller';
+import './controllers/cli.controller';
 import './credentials/credentials.controller';
 import './eventbus/event-bus.controller';
 import './events/events.controller';

package/dist/server.js

@@ -97,6 +97,7 @@ require("./controllers/users.controller");
 require("./controllers/user-settings.controller");
 require("./controllers/workflow-statistics.controller");
 require("./controllers/api-keys.controller");
+require("./controllers/cli.controller");
 require("./credentials/credentials.controller");
 require("./eventbus/event-bus.controller");
 require("./events/events.controller");

package/dist/services/cors-service.d.ts

@@ -0,0 +1,7 @@
+import type { CorsOptions } from '@n8n/decorators';
+import type { Response, Request } from 'express';
+export declare class CorsService {
+    private readonly defaultOptions;
+    applyCorsHeaders(req: Request, res: Response, options?: Partial<CorsOptions>): boolean;
+    private isOriginAllowed;
+}

package/dist/services/cors-service.js

@@ -0,0 +1,50 @@
+"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.CorsService = void 0;
+const di_1 = require("@n8n/di");
+let CorsService = class CorsService {
+    constructor() {
+        this.defaultOptions = {
+            allowedOrigins: ['*'],
+            allowedMethods: ['get', 'post', 'options', 'put', 'patch', 'delete'],
+            allowedHeaders: ['Origin', 'X-Requested-With', 'Content-Type', 'Accept'],
+            maxAge: 86400,
+        };
+    }
+    applyCorsHeaders(req, res, options) {
+        const config = { ...this.defaultOptions, ...options };
+        const requestOrigin = req.headers.origin;
+        if (!requestOrigin)
+            return false;
+        const isAllowed = this.isOriginAllowed(requestOrigin, config.allowedOrigins ?? []);
+        if (!isAllowed)
+            return false;
+        res.header('Access-Control-Allow-Origin', requestOrigin);
+        if (config.allowCredentials !== undefined) {
+            res.header('Access-Control-Allow-Credentials', `${config.allowCredentials}`);
+        }
+        if (config.allowedMethods) {
+            res.header('Access-Control-Allow-Methods', config.allowedMethods.join(', ').toUpperCase());
+        }
+        if (config.allowedHeaders) {
+            res.header('Access-Control-Allow-Headers', config.allowedHeaders.join(', '));
+        }
+        if (config.maxAge) {
+            res.header('Access-Control-Max-Age', config.maxAge.toString());
+        }
+        return true;
+    }
+    isOriginAllowed(origin, allowedOrigins) {
+        return allowedOrigins.includes('*') || allowedOrigins.includes(origin);
+    }
+};
+exports.CorsService = CorsService;
+exports.CorsService = CorsService = __decorate([
+    (0, di_1.Service)()
+], CorsService);

package/dist/services/static-auth-service.d.ts

@@ -0,0 +1,4 @@
+import { Request, Response, NextFunction } from 'express';
+export declare class StaticAuthService {
+    static getStaticAuthMiddleware(endpointAuthToken: string, headerName?: string): ((req: Request, res: Response, next: NextFunction) => void) | null;
+}

package/dist/services/static-auth-service.js

@@ -0,0 +1,29 @@
+"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.StaticAuthService = void 0;
+const di_1 = require("@n8n/di");
+let StaticAuthService = class StaticAuthService {
+    static getStaticAuthMiddleware(endpointAuthToken, headerName = 'authorization') {
+        if (!endpointAuthToken?.trim()) {
+            return null;
+        }
+        const expectedAuthorizationHeaderValue = `Bearer ${endpointAuthToken.trim()}`;
+        return (req, res, next) => {
+            if (req.headers[headerName] !== expectedAuthorizationHeaderValue) {
+                res.status(401).send('Unauthorized');
+                return;
+            }
+            next();
+        };
+    }
+};
+exports.StaticAuthService = StaticAuthService;
+exports.StaticAuthService = StaticAuthService = __decorate([
+    (0, di_1.Service)()
+], StaticAuthService);