@fsai-flow/core 0.0.4 → 0.1.0

package/dist/{src/lib → lib}/NodesLoader/types.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=types.js.map

package/dist/{src/lib → lib}/RedisLeaderElectionManager.d.ts

@@ -1,4 +1,4 @@
-import { RedisOptions } from 'ioredis';
+import { type RedisOptions } from "ioredis";
 export interface RedisLeaderElectionCallbacks {
     onStartedLeading: () => void;
     onStoppedLeading: () => void;

package/dist/lib/RedisLeaderElectionManager.js

@@ -0,0 +1,279 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisLeaderElectionManager = void 0;
+const workflow_1 = require("@fsai-flow/workflow");
+const ioredis_1 = __importDefault(require("ioredis"));
+class RedisLeaderElectionManager {
+    constructor(lockKey, redisConfig, callbacks) {
+        this.isLeader = false;
+        this.lockTTL = 30000; // 30 seconds in milliseconds
+        this.renewalInterval = 10000; // 10 seconds in milliseconds
+        this.lockKey = `leader:${lockKey}`;
+        this.nodeId = this.generateNodeId();
+        this.callbacks = callbacks;
+        // Initialize Redis connection
+        if (typeof redisConfig === "string") {
+            this.redis = new ioredis_1.default(redisConfig);
+        }
+        else {
+            this.redis = new ioredis_1.default(redisConfig);
+        }
+        // Handle Redis connection events
+        this.redis.on("connect", () => {
+            workflow_1.LoggerProxy.info(`Redis connected for leader election: ${this.lockKey}`);
+        });
+        this.redis.on("ready", () => {
+            workflow_1.LoggerProxy.info(`Redis ready for leader election: ${this.lockKey}`);
+        });
+        this.redis.on("error", (error) => {
+            workflow_1.LoggerProxy.error(`Redis connection error for leader election: ${error instanceof Error ? error.message : String(error)}`);
+        });
+    }
+    /**
+     * Wait for Redis connection to be ready
+     */
+    async waitForRedisConnection() {
+        return new Promise((resolve, reject) => {
+            if (this.redis.status === "ready") {
+                workflow_1.LoggerProxy.debug(`Redis already ready for ${this.lockKey}`);
+                resolve();
+                return;
+            }
+            let isSettled = false;
+            let timeoutId = null;
+            // Cleanup function to prevent memory leaks
+            const cleanup = () => {
+                if (isSettled)
+                    return; // Already cleaned up
+                isSettled = true;
+                // Clear timeout safely
+                if (timeoutId !== null) {
+                    clearTimeout(timeoutId);
+                    timeoutId = null;
+                }
+                // Remove event listeners safely
+                try {
+                    this.redis.off("ready", onReady);
+                    this.redis.off("error", onError);
+                }
+                catch (error) {
+                    // Ignore cleanup errors - Redis connection might be destroyed
+                    workflow_1.LoggerProxy.debug(`Cleanup warning for ${this.lockKey}: ${error}`);
+                }
+            };
+            const onReady = () => {
+                cleanup();
+                workflow_1.LoggerProxy.debug(`Redis connection established for ${this.lockKey}`);
+                resolve();
+            };
+            const onError = (error) => {
+                cleanup();
+                workflow_1.LoggerProxy.error(`Redis connection failed for ${this.lockKey}: ${error.message}`);
+                reject(error);
+            };
+            const onTimeout = () => {
+                cleanup();
+                reject(new Error(`Redis connection timeout after 10 seconds for ${this.lockKey}`));
+            };
+            // Set up timeout
+            timeoutId = setTimeout(onTimeout, 10000); // 10 second timeout
+            // Set up event listeners
+            this.redis.once("ready", onReady);
+            this.redis.once("error", onError);
+        });
+    }
+    /**
+     * Start the leader election process
+     */
+    async start() {
+        workflow_1.LoggerProxy.info(`🚀 Starting Redis leader election for ${this.nodeId} on key ${this.lockKey}`);
+        workflow_1.LoggerProxy.info(`🔧 Leader election config: TTL=${this.lockTTL}ms, RenewalInterval=${this.renewalInterval}ms`);
+        // Wait for Redis connection to be ready
+        workflow_1.LoggerProxy.info(`⏳ ${this.nodeId} waiting for Redis connection...`);
+        await this.waitForRedisConnection();
+        workflow_1.LoggerProxy.info(`✅ Redis connection ready for ${this.nodeId}`);
+        // Try to acquire leadership immediately
+        workflow_1.LoggerProxy.info(`🎯 ${this.nodeId} making initial leadership attempt...`);
+        await this.tryAcquireLeadership();
+        // Start the renewal/retry loop
+        this.startRenewalLoop();
+        workflow_1.LoggerProxy.info(`✅ Leader election process started for ${this.nodeId}`);
+    }
+    /**
+     * Stop the leader election process
+     */
+    async stop() {
+        workflow_1.LoggerProxy.info(`🛑 Stopping Redis leader election for ${this.nodeId}`);
+        // Stop renewal timer
+        if (this.renewalTimer) {
+            workflow_1.LoggerProxy.debug(`⏹️  Stopping leadership monitoring loop for ${this.nodeId}`);
+            clearInterval(this.renewalTimer);
+            this.renewalTimer = undefined;
+        }
+        // Release leadership if we have it
+        if (this.isLeader) {
+            workflow_1.LoggerProxy.info(`👋 ${this.nodeId} releasing leadership voluntarily for ${this.lockKey}`);
+            await this.releaseLock();
+        }
+        // Close Redis connection
+        workflow_1.LoggerProxy.debug(`🔌 Disconnecting Redis for ${this.nodeId}`);
+        this.redis.disconnect();
+        workflow_1.LoggerProxy.info(`✅ Leader election stopped for ${this.nodeId}`);
+    }
+    /**
+     * Check if this node is currently the leader
+     */
+    getIsLeader() {
+        return this.isLeader;
+    }
+    /**
+     * Try to acquire leadership
+     */
+    async tryAcquireLeadership() {
+        try {
+            // Check if Redis connection is ready before attempting operations
+            if (this.redis.status !== "ready") {
+                workflow_1.LoggerProxy.warn(`Redis not ready for ${this.nodeId}, current status: ${this.redis.status}`);
+                return false;
+            }
+            workflow_1.LoggerProxy.debug(`Node ${this.nodeId} attempting to acquire leadership for ${this.lockKey}`);
+            // Use SET with NX (not exists) and PX (expire in milliseconds)
+            const result = await this.redis.set(this.lockKey, this.nodeId, "PX", this.lockTTL, "NX");
+            if (result === "OK") {
+                // Successfully acquired leadership
+                if (!this.isLeader) {
+                    this.isLeader = true;
+                    workflow_1.LoggerProxy.info(`🏆 Node ${this.nodeId} ACQUIRED LEADERSHIP for ${this.lockKey} (TTL: ${this.lockTTL}ms)`);
+                    this.callbacks.onStartedLeading();
+                }
+                else {
+                    workflow_1.LoggerProxy.debug(`Node ${this.nodeId} renewed leadership lock for ${this.lockKey}`);
+                }
+                return true;
+            }
+            // Failed to acquire leadership - check who is the current leader
+            const currentLeader = await this.redis.get(this.lockKey);
+            const lockTTL = await this.redis.pttl(this.lockKey);
+            if (currentLeader) {
+                if (currentLeader !== this.nodeId) {
+                    workflow_1.LoggerProxy.debug(`👑 Node ${this.nodeId} sees ${currentLeader} is the current leader for ${this.lockKey} (TTL: ${lockTTL}ms)`);
+                    if (this.callbacks.onNewLeader) {
+                        this.callbacks.onNewLeader(currentLeader);
+                    }
+                }
+            }
+            else {
+                workflow_1.LoggerProxy.debug(`Node ${this.nodeId} found no current leader for ${this.lockKey}, but failed to acquire lock`);
+            }
+            // Lost leadership if we previously had it
+            if (this.isLeader) {
+                this.isLeader = false;
+                workflow_1.LoggerProxy.info(`📉 Node ${this.nodeId} LOST LEADERSHIP for ${this.lockKey}`);
+                this.callbacks.onStoppedLeading();
+            }
+            return false;
+        }
+        catch (error) {
+            workflow_1.LoggerProxy.error(`❌ Error during leader election for ${this.nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+            // If we had leadership and there's an error, assume we lost it
+            if (this.isLeader) {
+                this.isLeader = false;
+                workflow_1.LoggerProxy.info(`💥 Node ${this.nodeId} LOST LEADERSHIP due to error: ${this.lockKey}`);
+                this.callbacks.onStoppedLeading();
+            }
+            return false;
+        }
+    }
+    /**
+     * Renew the leadership lock
+     */
+    async renewLock() {
+        try {
+            // Check if Redis connection is ready before attempting operations
+            if (this.redis.status !== "ready") {
+                workflow_1.LoggerProxy.warn(`Redis not ready for ${this.nodeId} renewal, current status: ${this.redis.status}`);
+                return false;
+            }
+            workflow_1.LoggerProxy.debug(`🔄 Node ${this.nodeId} attempting to renew leadership for ${this.lockKey}`);
+            // Use Lua script to atomically check ownership and renew
+            const script = `
+				if redis.call("get", KEYS[1]) == ARGV[1] then
+					return redis.call("pexpire", KEYS[1], ARGV[2])
+				else
+					return 0
+				end
+			`;
+            const result = await this.redis.eval(script, 1, this.lockKey, this.nodeId, this.lockTTL.toString());
+            if (result === 1) {
+                workflow_1.LoggerProxy.debug(`✅ Node ${this.nodeId} successfully renewed leadership for ${this.lockKey} (TTL: ${this.lockTTL}ms)`);
+                return true;
+            }
+            workflow_1.LoggerProxy.warn(`⚠️  Node ${this.nodeId} failed to renew leadership for ${this.lockKey} - lock no longer owned by this node`);
+            return false;
+        }
+        catch (error) {
+            workflow_1.LoggerProxy.error(`❌ Error renewing leadership lock for ${this.nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+        }
+    }
+    /**
+     * Release the leadership lock
+     */
+    async releaseLock() {
+        try {
+            // Use Lua script to atomically check ownership and delete
+            const script = `
+				if redis.call("get", KEYS[1]) == ARGV[1] then
+					return redis.call("del", KEYS[1])
+				else
+					return 0
+				end
+			`;
+            await this.redis.eval(script, 1, this.lockKey, this.nodeId);
+            workflow_1.LoggerProxy.info(`Node ${this.nodeId} released leadership lock for ${this.lockKey}`);
+        }
+        catch (error) {
+            workflow_1.LoggerProxy.error(`Error releasing lock for ${this.nodeId}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Start the renewal/retry loop
+     */
+    startRenewalLoop() {
+        workflow_1.LoggerProxy.info(`Starting leadership monitoring loop for ${this.nodeId} (check every ${this.renewalInterval}ms)`);
+        this.renewalTimer = setInterval(async () => {
+            if (this.isLeader) {
+                // Leader: Try to renew the lock
+                workflow_1.LoggerProxy.debug(`⏰ [LEADER] Node ${this.nodeId} periodic leadership renewal check`);
+                const renewed = await this.renewLock();
+                if (!renewed) {
+                    // Failed to renew - we lost leadership
+                    this.isLeader = false;
+                    workflow_1.LoggerProxy.info(`💔 [LEADER] Node ${this.nodeId} LOST LEADERSHIP (failed to renew) for ${this.lockKey}`);
+                    this.callbacks.onStoppedLeading();
+                }
+                else {
+                    // Successfully renewed - keeping leadership
+                    //Logger.info(`🔒 [LEADER] Node ${this.nodeId} RENEWED LEADERSHIP - staying active for ${this.lockKey}`);
+                }
+            }
+            else {
+                // Follower: Try to acquire leadership
+                workflow_1.LoggerProxy.debug(`⏰ [FOLLOWER] Node ${this.nodeId} checking for available leadership`);
+                await this.tryAcquireLeadership();
+            }
+        }, this.renewalInterval);
+    }
+    /**
+     * Generate a unique node identifier
+     */
+    generateNodeId() {
+        return (process.env["POD_NAME"] ||
+            process.env["HOSTNAME"] ||
+            `node-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`);
+    }
+}
+exports.RedisLeaderElectionManager = RedisLeaderElectionManager;

package/dist/lib/RequestTypes.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Local replacement types for the deprecated `request` and `request-promise-native` packages.
+ *
+ * These interfaces provide type compatibility for function signatures that previously
+ * referenced types from those packages. The actual HTTP implementation uses axios.
+ */
+import type * as http from "node:http";
+import type * as url from "node:url";
+export interface RequestOptions {
+    uri?: string | url.Url;
+    url?: string | url.Url;
+    method?: string;
+    headers?: Record<string, unknown>;
+    body?: unknown;
+    json?: unknown;
+    qs?: Record<string, unknown>;
+    form?: Record<string, unknown>;
+    formData?: Record<string, unknown>;
+    encoding?: string | null;
+    timeout?: number;
+    followRedirect?: boolean;
+    followAllRedirects?: boolean;
+    maxRedirects?: number;
+    proxy?: string | {
+        host: string;
+        port: number;
+        auth?: {
+            username: string;
+            password: string;
+        };
+        protocol?: string;
+    };
+    auth?: {
+        user?: string;
+        username?: string;
+        pass?: string;
+        password?: string;
+        bearer?: string;
+    };
+    agent?: http.Agent;
+    agentOptions?: Record<string, unknown>;
+    rejectUnauthorized?: boolean;
+    strictSSL?: boolean;
+    gzip?: boolean;
+    [key: string]: unknown;
+}
+export interface OptionsWithUri extends RequestOptions {
+    uri: string | url.Url;
+}
+export interface OptionsWithUrl extends RequestOptions {
+    url: string | url.Url;
+}
+export interface RequestPromiseOptions extends RequestOptions {
+    simple?: boolean;
+    resolveWithFullResponse?: boolean;
+    transform?: (body: unknown, response: unknown, resolveWithFullResponse?: boolean) => unknown;
+    transform2xxOnly?: boolean;
+}

package/dist/lib/RequestTypes.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Local replacement types for the deprecated `request` and `request-promise-native` packages.
+ *
+ * These interfaces provide type compatibility for function signatures that previously
+ * referenced types from those packages. The actual HTTP implementation uses axios.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/{src/lib → lib}/UserSettings.d.ts

@@ -1,4 +1,4 @@
-import { IUserSettings } from '..';
+import { type IUserSettings } from "..";
 /**
  * Creates the user settings if they do not exist yet
  *

package/dist/lib/UserSettings.js

@@ -0,0 +1,269 @@
+"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 __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.prepareUserSettings = prepareUserSettings;
+exports.getEncryptionKey = getEncryptionKey;
+exports.getInstanceId = getInstanceId;
+exports.addToUserSettings = addToUserSettings;
+exports.writeUserSettings = writeUserSettings;
+exports.getUserSettings = getUserSettings;
+exports.getUserSettingsPath = getUserSettingsPath;
+exports.getUserN8nFolderPath = getUserN8nFolderPath;
+exports.getUserN8nFolderCustomExtensionPath = getUserN8nFolderCustomExtensionPath;
+exports.getUserHome = getUserHome;
+const node_crypto_1 = require("node:crypto");
+/* eslint-disable no-param-reassign */
+/* eslint-disable @typescript-eslint/no-use-before-define */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_util_1 = require("node:util");
+// eslint-disable-next-line import/no-cycle
+const __1 = require("..");
+const fsAccess = (0, node_util_1.promisify)(fs.access);
+const fsReadFile = (0, node_util_1.promisify)(fs.readFile);
+const fsMkdir = (0, node_util_1.promisify)(fs.mkdir);
+const fsWriteFile = (0, node_util_1.promisify)(fs.writeFile);
+let settingsCache;
+/**
+ * Creates the user settings if they do not exist yet
+ *
+ * @export
+ */
+async function prepareUserSettings() {
+    const settingsPath = getUserSettingsPath();
+    let userSettings = await getUserSettings(settingsPath);
+    if (userSettings !== undefined) {
+        // Settings already exist, check if they contain the encryptionKey
+        if (userSettings.encryptionKey !== undefined) {
+            // Key already exists
+            if (userSettings.instanceId === undefined) {
+                userSettings.instanceId = await generateInstanceId(userSettings.encryptionKey);
+                settingsCache = userSettings;
+            }
+            return userSettings;
+        }
+    }
+    else {
+        userSettings = {};
+    }
+    if (process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE] !== undefined) {
+        // Use the encryption key which got set via environment
+        userSettings.encryptionKey = process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE];
+    }
+    else {
+        // Generate a new encryption key
+        userSettings.encryptionKey = (0, node_crypto_1.randomBytes)(24).toString("base64");
+    }
+    userSettings.instanceId = await generateInstanceId(userSettings.encryptionKey);
+    // eslint-disable-next-line no-console
+    console.log(`UserSettings were generated and saved to: ${settingsPath}`);
+    return writeUserSettings(userSettings, settingsPath);
+}
+/**
+ * Returns the encryption key which is used to encrypt
+ * the credentials.
+ *
+ * @export
+ * @returns
+ */
+async function getEncryptionKey() {
+    if (process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE] !== undefined) {
+        return process.env[__1.ENCRYPTION_KEY_ENV_OVERWRITE];
+    }
+    const userSettings = await getUserSettings();
+    if (userSettings === undefined) {
+        return undefined;
+    }
+    if (userSettings.encryptionKey === undefined) {
+        return undefined;
+    }
+    return userSettings.encryptionKey;
+}
+/**
+ * Returns the instance ID
+ *
+ * @export
+ * @returns
+ */
+async function getInstanceId() {
+    const userSettings = await getUserSettings();
+    if (userSettings === undefined) {
+        return "";
+    }
+    if (userSettings.instanceId === undefined) {
+        return "";
+    }
+    return userSettings.instanceId;
+}
+async function generateInstanceId(key) {
+    const hash = key
+        ? (0, node_crypto_1.createHash)("sha256")
+            .update(key.slice(Math.round(key.length / 2)))
+            .digest("hex")
+        : undefined;
+    return hash;
+}
+/**
+ * Adds/Overwrite the given settings in the currently
+ * saved user settings
+ *
+ * @export
+ * @param {IUserSettings} addSettings  The settings to add/overwrite
+ * @param {string} [settingsPath] Optional settings file path
+ * @returns {Promise<IUserSettings>}
+ */
+async function addToUserSettings(addSettings, settingsPath) {
+    const resolvedSettingsPath = settingsPath ?? getUserSettingsPath();
+    let userSettings = await getUserSettings(resolvedSettingsPath);
+    if (userSettings === undefined) {
+        userSettings = {};
+    }
+    // Add the settings
+    Object.assign(userSettings, addSettings);
+    return writeUserSettings(userSettings, resolvedSettingsPath);
+}
+/**
+ * Writes a user settings file
+ *
+ * @export
+ * @param {IUserSettings} userSettings The settings to write
+ * @param {string} [settingsPath] Optional settings file path
+ * @returns {Promise<IUserSettings>}
+ */
+async function writeUserSettings(userSettings, settingsPath) {
+    const resolvedSettingsPath = settingsPath ?? getUserSettingsPath();
+    const resolvedUserSettings = userSettings ?? {};
+    // Check if parent folder exists if not create it.
+    try {
+        await fsAccess(path.dirname(resolvedSettingsPath));
+    }
+    catch (_error) {
+        // Parent folder does not exist so create
+        await fsMkdir(path.dirname(resolvedSettingsPath));
+    }
+    const settingsToWrite = { ...resolvedUserSettings };
+    if (settingsToWrite.instanceId !== undefined) {
+        settingsToWrite.instanceId = undefined;
+    }
+    await fsWriteFile(resolvedSettingsPath, JSON.stringify(settingsToWrite, null, "\t"));
+    settingsCache = JSON.parse(JSON.stringify(resolvedUserSettings));
+    return resolvedUserSettings;
+}
+/**
+ * Returns the content of the user settings
+ *
+ * @export
+ * @returns {UserSettings}
+ */
+async function getUserSettings(settingsPath, ignoreCache) {
+    if (settingsCache !== undefined && ignoreCache !== true) {
+        return settingsCache;
+    }
+    const resolvedSettingsPath = settingsPath ?? getUserSettingsPath();
+    try {
+        await fsAccess(resolvedSettingsPath);
+    }
+    catch (_error) {
+        // The file does not exist
+        return undefined;
+    }
+    const settingsFile = await fsReadFile(resolvedSettingsPath, "utf8");
+    try {
+        settingsCache = JSON.parse(settingsFile);
+    }
+    catch (_error) {
+        throw new Error(`Error parsing n8n-config file "${resolvedSettingsPath}". It does not seem to be valid JSON.`);
+    }
+    return settingsCache;
+}
+/**
+ * Returns the path to the user settings
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserSettingsPath() {
+    const n8nFolder = getUserN8nFolderPath();
+    return path.join(n8nFolder, __1.USER_SETTINGS_FILE_NAME);
+}
+/**
+ * Retruns the path to the n8n folder in which all n8n
+ * related data gets saved
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserN8nFolderPath() {
+    let userFolder;
+    if (process.env[__1.USER_FOLDER_ENV_OVERWRITE] !== undefined) {
+        userFolder = process.env[__1.USER_FOLDER_ENV_OVERWRITE];
+    }
+    else {
+        userFolder = getUserHome();
+    }
+    return path.join(userFolder, __1.USER_SETTINGS_SUBFOLDER);
+}
+/**
+ * Returns the path to the n8n user folder with the custom
+ * extensions like nodes and credentials
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserN8nFolderCustomExtensionPath() {
+    return path.join(getUserN8nFolderPath(), __1.EXTENSIONS_SUBDIRECTORY);
+}
+/**
+ * Returns the home folder path of the user if
+ * none can be found it falls back to the current
+ * working directory
+ *
+ * @export
+ * @returns {string}
+ */
+function getUserHome() {
+    let variableName = "HOME";
+    if (process.platform === "win32") {
+        variableName = "USERPROFILE";
+    }
+    if (process.env[variableName] === undefined) {
+        // If for some reason the variable does not exist
+        // fall back to current folder
+        return process.cwd();
+    }
+    return process.env[variableName];
+}

package/dist/{src/lib → lib}/WorkflowExecute.d.ts

@@ -1,5 +1,5 @@
-import PCancelable = require('p-cancelable');
-import { ExecutionError, IConnection, INode, INodeExecutionData, IRun, IRunData, IRunExecutionData, IWorkflowExecuteAdditionalData, Workflow, WorkflowExecuteMode } from '@fsai-flow/workflow';
+import { type ExecutionError, type IConnection, type INode, type INodeExecutionData, type IRun, type IRunData, type IRunExecutionData, type IWorkflowExecuteAdditionalData, type Workflow, type WorkflowExecuteMode } from "@fsai-flow/workflow";
+import PCancelable from "p-cancelable";
 export declare class WorkflowExecute {
     runExecutionData: IRunExecutionData;
     private additionalData;
@@ -30,11 +30,11 @@ export declare class WorkflowExecute {
      * Executes the hook with the given name
      *
      * @param {string} hookName
-     * @param {any[]} parameters
+     * @param {unknown[]} parameters
      * @returns {Promise<IRun>}
      * @memberof WorkflowExecute
      */
-    executeHook(hookName: string, parameters: any[]): Promise<void>;
+    executeHook(hookName: string, parameters: unknown[]): Promise<void>;
     /**
      * Checks the incoming connection does not receive any data
      */