@motiadev/core 0.0.19 → 0.0.21

package/dist/index.d.ts

@@ -4,8 +4,7 @@ export * from './src/step-handlers';
 export * from './src/event-manager';
 export * from './src/logger';
 export * from './src/state/create-state-adapter';
-export * from './src/python/get-python-config';
-export * from './src/ruby/get-ruby-config';
-export * from './src/node/get-config';
 export * from './src/cron-handler';
 export * from './src/guards';
+export * from './src/locked-data';
+export * from './src/get-step-config';

package/dist/index.js

@@ -20,8 +20,7 @@ __exportStar(require("./src/step-handlers"), exports);
 __exportStar(require("./src/event-manager"), exports);
 __exportStar(require("./src/logger"), exports);
 __exportStar(require("./src/state/create-state-adapter"), exports);
-__exportStar(require("./src/python/get-python-config"), exports);
-__exportStar(require("./src/ruby/get-ruby-config"), exports);
-__exportStar(require("./src/node/get-config"), exports);
 __exportStar(require("./src/cron-handler"), exports);
 __exportStar(require("./src/guards"), exports);
+__exportStar(require("./src/locked-data"), exports);
+__exportStar(require("./src/get-step-config"), exports);

package/dist/src/call-step-file.d.ts

@@ -1,2 +1,3 @@
-import { Event, EventManager, InternalStateManager } from './types';
-export declare const callStepFile: <TData>(stepPath: string, step: string, event: Event<TData>, eventManager: EventManager, state: InternalStateManager) => Promise<void>;
+import { LockedData } from './locked-data';
+import { Event, EventConfig, EventManager, InternalStateManager, Step } from './types';
+export declare const callStepFile: <TData>(step: Step<EventConfig>, lockedData: LockedData, event: Event<TData>, eventManager: EventManager, state: InternalStateManager) => Promise<void>;

package/dist/src/call-step-file.js

@@ -7,6 +7,7 @@ exports.callStepFile = void 0;
 const step_handler_rpc_processor_1 = require("./step-handler-rpc-processor");
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
 const nodeRunner = path_1.default.join(__dirname, 'node', 'node-runner.js');
 const pythonRunner = path_1.default.join(__dirname, 'python', 'python-runner.py');
 const rubyRunner = path_1.default.join(__dirname, 'ruby', 'ruby_runner.rb');
@@ -25,28 +26,31 @@ const getLanguageBasedRunner = (stepFilePath = '') => {
     }
     throw Error(`Unsupported file extension ${stepFilePath}`);
 };
-const callStepFile = (stepPath, step, event, eventManager, state) => {
+const callStepFile = (step, lockedData, event, eventManager, state) => {
     return new Promise((resolve, reject) => {
         const jsonData = JSON.stringify({ ...event });
-        const { runner, command } = getLanguageBasedRunner(stepPath);
-        const child = (0, child_process_1.spawn)(command, [runner, stepPath, jsonData], {
+        const { runner, command } = getLanguageBasedRunner(step.filePath);
+        const child = (0, child_process_1.spawn)(command, [runner, step.filePath, jsonData], {
             stdio: [undefined, undefined, undefined, 'ipc'],
         });
         const rpcProcessor = new step_handler_rpc_processor_1.RpcProcessor(child);
-        rpcProcessor.handler('log', async (input) => {
-            event.logger.log(input);
-        });
+        rpcProcessor.handler('close', async () => child.kill());
+        rpcProcessor.handler('log', async (input) => event.logger.log(input));
         rpcProcessor.handler('state.get', (input) => state.get(input.traceId, input.key));
         rpcProcessor.handler('state.set', (input) => state.set(input.traceId, input.key, input.value));
         rpcProcessor.handler('state.delete', (input) => state.delete(input.traceId, input.key));
         rpcProcessor.handler('state.clear', (input) => state.clear(input.traceId));
-        rpcProcessor.handler('emit', (input) => {
+        rpcProcessor.handler('emit', async (input) => {
+            if (!(0, utils_1.isAllowedToEmit)(step, input.type)) {
+                lockedData.printer.printInvalidEmit(step, input.type);
+                return;
+            }
             return eventManager.emit({
                 ...input,
                 traceId: event.traceId,
                 flows: event.flows,
                 logger: event.logger,
-            }, stepPath);
+            }, step.filePath);
         });
         rpcProcessor.init();
         child.stdout?.on('data', (data) => {
@@ -60,7 +64,7 @@ const callStepFile = (stepPath, step, event, eventManager, state) => {
         });
         child.stderr?.on('data', (data) => event.logger.error(Buffer.from(data).toString(), { step }));
         child.on('close', (code) => {
-            if (code !== 0) {
+            if (code !== 0 && code !== null) {
                 reject(new Error(`Process exited with code ${code}`));
             }
             else {

package/dist/src/cron-handler.d.ts

@@ -1,3 +1,13 @@
-import { EventManager, Step } from './types';
 import { Server } from 'socket.io';
-export declare const setupCronHandlers: (steps: Step[], eventManager: EventManager, socketServer?: Server) => () => void;
+import { LockedData } from './locked-data';
+import { EventManager, Step, CronConfig } from './types';
+export type CronManager = {
+    createCronJob: (step: Step<CronConfig>) => void;
+    removeCronJob: (step: Step<CronConfig>) => void;
+    close: () => void;
+};
+export declare const setupCronHandlers: (lockedData: LockedData, eventManager: EventManager, socketServer: Server) => {
+    createCronJob: (step: Step<CronConfig>) => void;
+    removeCronJob: (step: Step<CronConfig>) => void;
+    close: () => void;
+};

package/dist/src/cron-handler.js

@@ -34,13 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupCronHandlers = void 0;
-const logger_1 = require("./logger");
 const cron = __importStar(require("node-cron"));
-const guards_1 = require("./guards");
+const logger_1 = require("./logger");
 const get_module_export_1 = require("./node/get-module-export");
-const cronJobs = new Map();
-const setupCronHandlers = (steps, eventManager, socketServer) => {
-    steps.filter(guards_1.isCronStep).forEach(async (step) => {
+const setupCronHandlers = (lockedData, eventManager, socketServer) => {
+    const cronJobs = new Map();
+    const createCronJob = (step) => {
         const { config, filePath } = step;
         const { cron: cronExpression } = config;
         if (!cron.validate(cronExpression)) {
@@ -58,24 +57,21 @@ const setupCronHandlers = (steps, eventManager, socketServer) => {
         const task = cron.schedule(cronExpression, async () => {
             const traceId = Math.random().toString(36).substring(7);
             const logger = new logger_1.Logger(traceId, config.flows, step.config.name, socketServer);
+            const flows = config.flows;
             try {
                 const handler = await (0, get_module_export_1.getModuleExport)(filePath, 'handler');
                 const emit = async (event) => {
-                    await eventManager.emit({
-                        ...event,
-                        traceId,
-                        flows: config.flows,
-                        logger,
-                    }, filePath);
+                    await eventManager.emit({ ...event, traceId, flows, logger }, filePath);
                 };
                 if (handler) {
                     await handler({ emit, logger, traceId });
                 }
                 else {
-                    await emit({
-                        type: config.emits[0],
-                        data: { timestamp: Date.now() },
-                    });
+                    const data = { timestamp: Date.now() };
+                    await Promise.all(config.emits.map((item) => {
+                        const type = typeof item === 'string' ? item : item.type;
+                        emit({ type, data });
+                    }));
                 }
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
             }
@@ -86,11 +82,20 @@ const setupCronHandlers = (steps, eventManager, socketServer) => {
                 });
             }
         });
-        cronJobs.set(step.config.name, task);
-    });
-    return () => {
+        cronJobs.set(step.filePath, task);
+    };
+    const removeCronJob = (step) => {
+        const task = cronJobs.get(step.filePath);
+        if (task) {
+            task.stop();
+            cronJobs.delete(step.filePath);
+        }
+    };
+    const close = () => {
         cronJobs.forEach((task) => task.stop());
         cronJobs.clear();
     };
+    lockedData.cronSteps().forEach(createCronJob);
+    return { createCronJob, removeCronJob, close };
 };
 exports.setupCronHandlers = setupCronHandlers;

package/dist/src/event-manager.js

@@ -8,15 +8,20 @@ const createEventManager = () => {
         const eventHandlers = handlers[event.type] ?? [];
         const { logger, ...rest } = event;
         logger.debug('[Flow Emit] Event emitted', { handlers: eventHandlers.length, data: rest, file });
-        eventHandlers.map((handler) => handler(event));
+        eventHandlers.map((eventHandler) => eventHandler.handler(event));
     };
-    const subscribe = (event, handlerName, handler) => {
+    const subscribe = (config) => {
+        const { event, handlerName, handler, filePath } = config;
         if (!handlers[event]) {
             handlers[event] = [];
         }
         logger_1.globalLogger.debug('[Flow Sub] Subscribing to event', { event, handlerName });
-        handlers[event].push(handler);
+        handlers[event].push({ filePath, handler: handler });
     };
-    return { emit, subscribe };
+    const unsubscribe = (config) => {
+        const { filePath, event } = config;
+        handlers[event] = handlers[event].filter((handler) => handler.filePath !== filePath);
+    };
+    return { emit, subscribe, unsubscribe };
 };
 exports.createEventManager = createEventManager;

package/dist/src/flows-endpoint.d.ts

@@ -1,5 +1,6 @@
 import { Express } from 'express';
-import { Emit, LockedData } from './types';
+import { Emit } from './types';
+import { LockedData } from './locked-data';
 type FlowListResponse = {
     id: string;
     name: string;
@@ -34,6 +35,6 @@ type FlowResponse = FlowListResponse & {
     steps: FlowStepResponse[];
     edges: FlowEdge[];
 };
-export declare const flowsEndpoint: (flows: LockedData["flows"], app: Express) => void;
-export declare const generateFlowsList: (flows: LockedData["flows"]) => FlowResponse[];
+export declare const flowsEndpoint: (lockedData: LockedData, app: Express) => void;
+export declare const generateFlowsList: (lockedData: LockedData) => FlowResponse[];
 export {};

package/dist/src/flows-endpoint.js

@@ -9,12 +9,13 @@ const fs_1 = __importDefault(require("fs"));
 const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const guards_1 = require("./guards");
 const get_step_language_1 = require("./get-step-language");
-const flowsEndpoint = (flows, app) => {
-    const list = (0, exports.generateFlowsList)(flows);
+const flowsEndpoint = (lockedData, app) => {
     app.get('/flows', async (_, res) => {
+        const list = (0, exports.generateFlowsList)(lockedData);
         res.status(200).send(list.map(({ id, name }) => ({ id, name })));
     });
     app.get('/flows/:id', async (req, res) => {
+        const list = (0, exports.generateFlowsList)(lockedData);
         const { id } = req.params;
         const flow = list.find((flow) => flow.id === id);
         if (!flow) {
@@ -26,8 +27,8 @@ const flowsEndpoint = (flows, app) => {
     });
 };
 exports.flowsEndpoint = flowsEndpoint;
-const generateFlowsList = (flows) => {
-    return Object.entries(flows).map(([flowId, flow]) => generateFlow(flowId, flow.steps));
+const generateFlowsList = (lockedData) => {
+    return Object.entries(lockedData.flows).map(([flowId, flow]) => generateFlow(flowId, flow.steps));
 };
 exports.generateFlowsList = generateFlowsList;
 // Helper functions

package/dist/src/get-step-config.d.ts

@@ -0,0 +1,2 @@
+import { StepConfig } from './types';
+export declare const getStepConfig: (filePath: string) => Promise<StepConfig | null>;

package/dist/src/get-step-config.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStepConfig = void 0;
+const get_config_1 = require("./node/get-config");
+const get_python_config_1 = require("./python/get-python-config");
+const get_ruby_config_1 = require("./ruby/get-ruby-config");
+const getStepConfig = async (filePath) => {
+    const isRb = filePath.endsWith('.rb');
+    const isPython = filePath.endsWith('.py');
+    const isNode = filePath.endsWith('.js') || filePath.endsWith('.ts');
+    if (isRb) {
+        return (0, get_ruby_config_1.getRubyConfig)(filePath);
+    }
+    else if (isPython) {
+        return (0, get_python_config_1.getPythonConfig)(filePath);
+    }
+    else if (isNode) {
+        return (0, get_config_1.getNodeFileConfig)(filePath);
+    }
+    return null;
+};
+exports.getStepConfig = getStepConfig;

package/dist/src/guards.d.ts

@@ -1,5 +1,5 @@
 import { ApiRouteConfig, EventConfig, NoopConfig, Step, CronConfig } from './types';
 export declare const isApiStep: (step: Step) => step is Step<ApiRouteConfig>;
-export declare const isEventStep: (step: Step) => step is Step<EventConfig<any>>;
+export declare const isEventStep: (step: Step) => step is Step<EventConfig>;
 export declare const isNoopStep: (step: Step) => step is Step<NoopConfig>;
 export declare const isCronStep: (step: Step) => step is Step<CronConfig>;

package/dist/src/guards.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isCronStep = exports.isNoopStep = exports.isEventStep = exports.isApiStep = void 0;
 const isApiStep = (step) => step.config.type === 'api';
 exports.isApiStep = isApiStep;
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
 const isEventStep = (step) => step.config.type === 'event';
 exports.isEventStep = isEventStep;
 const isNoopStep = (step) => step.config.type === 'noop';

package/dist/src/locked-data.d.ts

@@ -0,0 +1,26 @@
+import { ZodObject } from 'zod';
+import { ApiRouteConfig, CronConfig, EventConfig, Flow, Step } from './types';
+import { Printer } from './printer';
+type FlowEvent = 'flow-created' | 'flow-removed' | 'flow-updated';
+export declare class LockedData {
+    readonly baseDir: string;
+    flows: Record<string, Flow>;
+    activeSteps: Step[];
+    devSteps: Step[];
+    readonly printer: Printer;
+    private stepsMap;
+    private handlers;
+    constructor(baseDir: string);
+    on(event: FlowEvent, handler: (flowName: string) => void): void;
+    eventSteps(): Step<EventConfig<ZodObject<any>>>[];
+    apiSteps(): Step<ApiRouteConfig>[];
+    cronSteps(): Step<CronConfig>[];
+    updateStep(oldStep: Step, newStep: Step): boolean;
+    createStep(step: Step): boolean;
+    deleteStep(step: Step): void;
+    private createFlow;
+    private removeFlow;
+    private onFlowUpdated;
+    private isValidStep;
+}
+export {};

package/dist/src/locked-data.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockedData = void 0;
+const guards_1 = require("./guards");
+const step_validator_1 = require("./step-validator");
+const printer_1 = require("./printer");
+class LockedData {
+    constructor(baseDir) {
+        this.baseDir = baseDir;
+        this.flows = {};
+        this.activeSteps = [];
+        this.devSteps = [];
+        this.stepsMap = {};
+        this.printer = new printer_1.Printer(baseDir);
+        this.handlers = {
+            'flow-created': [],
+            'flow-removed': [],
+            'flow-updated': [],
+        };
+    }
+    on(event, handler) {
+        this.handlers[event].push(handler);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    eventSteps() {
+        return this.activeSteps.filter(guards_1.isEventStep);
+    }
+    apiSteps() {
+        return this.activeSteps.filter(guards_1.isApiStep);
+    }
+    cronSteps() {
+        return this.activeSteps.filter(guards_1.isCronStep);
+    }
+    updateStep(oldStep, newStep) {
+        if (!this.isValidStep(newStep)) {
+            this.deleteStep(oldStep);
+            return false;
+        }
+        if (oldStep.config.type !== newStep.config.type) {
+            this.activeSteps = this.activeSteps.filter((s) => s.filePath !== oldStep.filePath);
+            this.devSteps = this.devSteps.filter((s) => s.filePath !== oldStep.filePath);
+            if (newStep.config.virtualEmits) {
+                this.devSteps.push(newStep);
+            }
+            else {
+                this.activeSteps.push(newStep);
+            }
+        }
+        const savedStep = this.stepsMap[newStep.filePath];
+        const addedFlows = newStep.config.flows?.filter((flowName) => !oldStep.config.flows?.includes(flowName)) ?? [];
+        const removedFlows = oldStep.config.flows?.filter((flowName) => !newStep.config.flows?.includes(flowName)) ?? [];
+        const untouchedFlows = oldStep.config.flows?.filter((flowName) => newStep.config.flows?.includes(flowName)) ?? [];
+        untouchedFlows.forEach((flowName) => this.onFlowUpdated(flowName));
+        for (const flowName of addedFlows) {
+            if (!this.flows[flowName]) {
+                const flow = this.createFlow(flowName);
+                flow.steps.push(savedStep);
+            }
+            else {
+                this.flows[flowName].steps.push(savedStep);
+                this.onFlowUpdated(flowName);
+            }
+        }
+        for (const flowName of removedFlows) {
+            const flowSteps = this.flows[flowName].steps;
+            this.flows[flowName].steps = flowSteps.filter(({ filePath }) => filePath !== newStep.filePath);
+            if (this.flows[flowName].steps.length === 0) {
+                this.removeFlow(flowName);
+            }
+            else {
+                this.onFlowUpdated(flowName);
+            }
+        }
+        savedStep.config = newStep.config;
+        this.printer.printStepUpdated(newStep);
+        return true;
+    }
+    createStep(step) {
+        if (!this.isValidStep(step)) {
+            return false;
+        }
+        this.stepsMap[step.filePath] = step;
+        if (step.config.virtualEmits) {
+            this.devSteps.push(step);
+        }
+        else {
+            this.activeSteps.push(step);
+        }
+        for (const flowName of step.config.flows ?? []) {
+            if (!this.flows[flowName]) {
+                const flow = this.createFlow(flowName);
+                flow.steps.push(step);
+            }
+            else {
+                this.flows[flowName].steps.push(step);
+                this.onFlowUpdated(flowName);
+            }
+        }
+        this.printer.printStepCreated(step);
+        return true;
+    }
+    deleteStep(step) {
+        // Remove step from active and dev steps
+        this.activeSteps = this.activeSteps.filter(({ filePath }) => filePath !== step.filePath);
+        this.devSteps = this.devSteps.filter(({ filePath }) => filePath !== step.filePath);
+        delete this.stepsMap[step.filePath];
+        for (const flowName of step.config.flows ?? []) {
+            const stepFlows = this.flows[flowName]?.steps;
+            if (stepFlows) {
+                this.flows[flowName].steps = stepFlows.filter(({ filePath }) => filePath !== step.filePath);
+            }
+            if (this.flows[flowName].steps.length === 0) {
+                this.removeFlow(flowName);
+            }
+            else {
+                this.onFlowUpdated(flowName);
+            }
+        }
+        this.printer.printStepRemoved(step);
+    }
+    createFlow(flowName) {
+        const flow = { name: flowName, description: '', steps: [] };
+        this.flows[flowName] = flow;
+        this.handlers['flow-created'].forEach((handler) => handler(flowName));
+        this.printer.printFlowCreated(flowName);
+        return flow;
+    }
+    removeFlow(flowName) {
+        delete this.flows[flowName];
+        this.handlers['flow-removed'].forEach((handler) => handler(flowName));
+        this.printer.printFlowRemoved(flowName);
+    }
+    onFlowUpdated(flowName) {
+        this.handlers['flow-updated'].forEach((handler) => handler(flowName));
+    }
+    isValidStep(step) {
+        const validationResult = (0, step_validator_1.validateStep)(step);
+        if (!validationResult.success) {
+            this.printer.printValidationError(step.filePath, validationResult);
+        }
+        return validationResult.success;
+    }
+}
+exports.LockedData = LockedData;

package/dist/src/logger.d.ts

@@ -12,7 +12,7 @@ export declare class Logger extends BaseLogger {
     private readonly flows;
     private readonly file;
     private emitLog;
-    constructor(traceId: string, flows: string[], file: string, socketServer?: Server);
+    constructor(traceId: string, flows: string[] | undefined, file: string, socketServer?: Server);
     log(message: any): void;
     info: (message: string, args?: unknown) => void;
     error: (message: string, args?: unknown) => void;

package/dist/src/node/get-module-export.js

@@ -53,13 +53,16 @@ require('ts-node').register({
 const getModuleExport = async (filePath, exportName) => {
     try {
         const resolvedFilePath = require.resolve(filePath);
+        if (resolvedFilePath in require.cache) {
+            delete require.cache[resolvedFilePath];
+        }
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const module = require(resolvedFilePath);
         return module[exportName];
     }
     catch (error) {
-        console.error(`Failed to extract ${exportName} from ${filePath}:`, error);
-        throw new Error(`No ${exportName} found in step ${filePath}`);
+        console.error(`Failed to extract ${exportName} from`, error);
+        return undefined;
     }
 };
 exports.getModuleExport = getModuleExport;

package/dist/src/node/logger.d.ts

@@ -1,8 +1,13 @@
+import { RpcSender } from './rpc';
 export declare class Logger {
-    private logger;
-    constructor(traceId: string, flows: string[], file?: string);
-    info: (message: string, args: Record<string, unknown>) => void;
-    error: (message: string, args: Record<string, unknown>) => void;
-    debug: (message: string, args: Record<string, unknown>) => void;
-    warn: (message: string, args: Record<string, unknown>) => void;
+    private readonly traceId;
+    private readonly flows;
+    private readonly fileName;
+    private readonly sender;
+    constructor(traceId: string, flows: string[], fileName: string, sender: RpcSender);
+    private _log;
+    info(message: string, args?: Record<string, unknown>): void;
+    error(message: string, args?: Record<string, unknown>): void;
+    debug(message: string, args?: Record<string, unknown>): void;
+    warn(message: string, args?: Record<string, unknown>): void;
 }

package/dist/src/node/logger.js

@@ -1,23 +1,36 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Logger = void 0;
-const pino_1 = __importDefault(require("pino"));
 class Logger {
-    constructor(traceId, flows, file) {
-        this.info = (message, args) => this.logger.info(args, message);
-        this.error = (message, args) => this.logger.error(args, message);
-        this.debug = (message, args) => this.logger.debug(args, message);
-        this.warn = (message, args) => this.logger.warn(args, message);
-        this.logger = (0, pino_1.default)({
-            level: 'info',
-            formatters: { level: (level) => ({ level }) },
-            errorKey: 'error',
-            base: null,
-            mixin: () => ({ traceId, flows, file }),
-        });
+    constructor(traceId, flows, fileName, sender) {
+        this.traceId = traceId;
+        this.flows = flows;
+        this.fileName = fileName;
+        this.sender = sender;
+    }
+    _log(level, message, args) {
+        const logEntry = {
+            ...(args || {}),
+            level,
+            time: Date.now(),
+            traceId: this.traceId,
+            flows: this.flows,
+            file: this.fileName,
+            msg: message,
+        };
+        this.sender.sendNoWait('log', logEntry);
+    }
+    info(message, args) {
+        this._log('info', message, args);
+    }
+    error(message, args) {
+        this._log('error', message, args);
+    }
+    debug(message, args) {
+        this._log('debug', message, args);
+    }
+    warn(message, args) {
+        this._log('warn', message, args);
     }
 }
 exports.Logger = Logger;

package/dist/src/node/node-runner.js

@@ -21,7 +21,7 @@ function parseArgs(arg) {
         return arg;
     }
 }
-async function runTypescriptModule(filePath, args) {
+async function runTypescriptModule(filePath, event) {
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
         const module = require(path_1.default.resolve(filePath));
@@ -29,17 +29,16 @@ async function runTypescriptModule(filePath, args) {
         if (typeof module.handler !== 'function') {
             throw new Error(`Function handler not found in module ${filePath}`);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const { stateConfig, ...event } = args;
         const { traceId, flows } = event;
-        const logger = new logger_1.Logger(traceId, flows, filePath.split('/').pop());
         const sender = new rpc_1.RpcSender(process);
+        const logger = new logger_1.Logger(traceId, flows, filePath, sender);
         const state = new rpc_state_manager_1.RpcStateManager(sender);
         const emit = async (data) => sender.send('emit', data);
         const context = { traceId, flows, logger, state, emit };
         sender.init();
         // Call the function with provided arguments
         await module.handler(event.data, context);
+        await sender.close();
         process.exit(0);
     }
     catch (error) {

package/dist/src/node/rpc.d.ts

@@ -2,6 +2,8 @@ export declare class RpcSender {
     private readonly process;
     private readonly pendingRequests;
     constructor(process: NodeJS.Process);
+    close(): Promise<void>;
     send<T>(method: string, args: unknown): Promise<T>;
+    sendNoWait(method: string, args: unknown): void;
     init(): void;
 }

package/dist/src/node/rpc.js

@@ -11,13 +11,23 @@ class RpcSender {
         this.process = process;
         this.pendingRequests = {};
     }
+    async close() {
+        const outstandingRequests = Object.values(this.pendingRequests);
+        if (outstandingRequests.length > 0) {
+            console.error('Process ended while there are some promises outstanding');
+            this.process.exit(1);
+        }
+    }
     send(method, args) {
         return new Promise((resolve, reject) => {
             const id = crypto_1.default.randomUUID();
             this.pendingRequests[id] = { resolve, reject, method, args };
-            process.send?.({ type: 'rpc_request', id, method, args });
+            this.process.send?.({ type: 'rpc_request', id, method, args });
         });
     }
+    sendNoWait(method, args) {
+        this.process.send?.({ type: 'rpc_request', method, args });
+    }
     init() {
         this.process.on('message', (msg) => {
             if (msg.type === 'rpc_response') {

package/dist/src/printer.d.ts

@@ -0,0 +1,17 @@
+import { ValidationError } from './step-validator';
+import { Step } from './types';
+export declare class Printer {
+    private readonly baseDir;
+    constructor(baseDir: string);
+    printInvalidEmit(step: Step, emit: string): void;
+    printStepCreated(step: Step): void;
+    printStepUpdated(step: Step): void;
+    printStepRemoved(step: Step): void;
+    printFlowCreated(flowName: string): void;
+    printFlowUpdated(flowName: string): void;
+    printFlowRemoved(flowName: string): void;
+    printValidationError(stepPath: string, validationError: ValidationError): void;
+    private getRelativePath;
+    private getStepType;
+    private getStepPath;
+}