@motiadev/core 0.0.28 → 0.0.30

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Motia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE. 

package/dist/src/LoggerFactory.d.ts

@@ -0,0 +1,14 @@
+import { Server } from 'socket.io';
+import { Logger } from './logger';
+type CreateLogger = {
+    traceId: string;
+    flows?: string[];
+    stepName: string;
+};
+export declare class LoggerFactory {
+    private readonly isVerbose;
+    private readonly socketServer;
+    constructor(isVerbose: boolean, socketServer: Server);
+    create({ stepName, traceId, flows }: CreateLogger): Logger;
+}
+export {};

package/dist/src/LoggerFactory.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactory = void 0;
+const logger_1 = require("./logger");
+class LoggerFactory {
+    constructor(isVerbose, socketServer) {
+        this.isVerbose = isVerbose;
+        this.socketServer = socketServer;
+    }
+    create({ stepName, traceId, flows }) {
+        return new logger_1.Logger(traceId, flows, stepName, this.isVerbose, this.socketServer);
+    }
+}
+exports.LoggerFactory = LoggerFactory;

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

@@ -52,8 +52,8 @@ const callStepFile = (options) => {
             result = input;
         });
         rpcProcessor.handler('emit', async (input) => {
-            if (!(0, utils_1.isAllowedToEmit)(step, input.type)) {
-                return printer.printInvalidEmit(step, input.type);
+            if (!(0, utils_1.isAllowedToEmit)(step, input.topic)) {
+                return printer.printInvalidEmit(step, input.topic);
             }
             return eventManager.emit({ ...input, traceId, flows: step.config.flows, logger }, step.filePath);
         });
@@ -70,12 +70,20 @@ const callStepFile = (options) => {
         child.stderr?.on('data', (data) => logger.error(Buffer.from(data).toString()));
         child.on('close', (code) => {
             if (code !== 0 && code !== null) {
-                reject(new Error(`Process exited with code ${code}`));
+                reject(`Process exited with code ${code}`);
             }
             else {
                 resolve(result);
             }
         });
+        child.on('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(`Executable ${command} not found`);
+            }
+            else {
+                reject(error);
+            }
+        });
     });
 };
 exports.callStepFile = callStepFile;

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

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

package/dist/src/cron-handler.js

@@ -34,16 +34,16 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setupCronHandlers = void 0;
-const crypto_1 = require("crypto");
 const cron = __importStar(require("node-cron"));
 const call_step_file_1 = require("./call-step-file");
 const logger_1 = require("./logger");
-const setupCronHandlers = (lockedData, eventManager, state, socketServer) => {
+const generate_trace_id_1 = require("./generate-trace-id");
+const setupCronHandlers = (lockedData, eventManager, state, loggerFactory) => {
     const cronJobs = new Map();
     const printer = lockedData.printer;
     const createCronJob = (step) => {
         const { config, filePath } = step;
-        const { cron: cronExpression, name: stepName } = config;
+        const { cron: cronExpression, name: stepName, flows } = config;
         if (!cron.validate(cronExpression)) {
             logger_1.globalLogger.error('[cron handler] invalid cron expression', {
                 expression: cronExpression,
@@ -57,8 +57,8 @@ const setupCronHandlers = (lockedData, eventManager, state, socketServer) => {
             cron: cronExpression,
         });
         const task = cron.schedule(cronExpression, async () => {
-            const traceId = (0, crypto_1.randomUUID)();
-            const logger = new logger_1.Logger(traceId, config.flows, stepName, socketServer);
+            const traceId = (0, generate_trace_id_1.generateTraceId)();
+            const logger = loggerFactory.create({ traceId, flows, stepName });
             try {
                 await (0, call_step_file_1.callStepFile)({
                     contextInFirstArg: true,

package/dist/src/event-manager.js

@@ -5,7 +5,7 @@ const logger_1 = require("./logger");
 const createEventManager = () => {
     const handlers = {};
     const emit = async (event, file) => {
-        const eventHandlers = handlers[event.type] ?? [];
+        const eventHandlers = handlers[event.topic] ?? [];
         const { logger, ...rest } = event;
         logger.debug('[Flow Emit] Event emitted', { handlers: eventHandlers.length, data: rest, file });
         eventHandlers.map((eventHandler) => eventHandler.handler(event));

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

@@ -7,7 +7,7 @@ type FlowListResponse = {
 };
 export type EdgeData = {
     variant: 'event' | 'virtual';
-    emitType: string;
+    topic: string;
     label?: string;
     labelVariant?: 'default' | 'conditional';
 };

package/dist/src/flows-endpoint.js

@@ -36,21 +36,21 @@ const getNodeComponentPath = (filePath) => {
     const tsxPath = filePathWithoutExtension + '.tsx';
     return fs_1.default.existsSync(tsxPath) ? tsxPath : undefined;
 };
-const createEdge = (sourceId, targetId, emitType, label, variant, conditional) => ({
+const createEdge = (sourceId, targetId, topic, label, variant, conditional) => ({
     id: `${sourceId}-${targetId}`,
     source: sourceId,
     target: targetId,
     data: {
         variant,
         label,
-        emitType,
+        topic,
         labelVariant: conditional ? 'conditional' : 'default',
     },
 });
 const processEmit = (emit) => {
     const isString = typeof emit === 'string';
     return {
-        type: isString ? emit : emit.type,
+        topic: isString ? emit : emit.topic,
         label: isString ? undefined : emit.label,
         conditional: isString ? undefined : emit.conditional,
     };
@@ -58,10 +58,10 @@ const processEmit = (emit) => {
 const createEdgesForEmits = (sourceStep, targetSteps, emits, variant) => {
     const edges = [];
     emits.forEach((emit) => {
-        const { type: emitType, label, conditional } = processEmit(emit);
+        const { topic, label, conditional } = processEmit(emit);
         targetSteps.forEach((targetStep) => {
-            if (targetStep.subscribes?.includes(emitType)) {
-                edges.push(createEdge(sourceStep.id, targetStep.id, emitType, label, variant, conditional));
+            if (targetStep.subscribes?.includes(topic)) {
+                edges.push(createEdge(sourceStep.id, targetStep.id, topic, label, variant, conditional));
             }
         });
     });

package/dist/src/generate-trace-id.d.ts

@@ -0,0 +1,2 @@
+export declare const generateCode: (length?: number) => string;
+export declare const generateTraceId: () => string;

package/dist/src/generate-trace-id.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTraceId = exports.generateCode = void 0;
+const generateCode = (length = 6) => {
+    const chars = 'ABCDEFGHJKMNPQRSTUVWXYZ123456789';
+    return Array.from({ length }, () => chars[Math.floor(Math.random() * chars.length)]).join('');
+};
+exports.generateCode = generateCode;
+const generateTraceId = () => {
+    const datePart = String(Date.now()).slice(6);
+    const randomPart = (0, exports.generateCode)(5);
+    return `${randomPart}-${datePart}`;
+};
+exports.generateTraceId = generateTraceId;

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

@@ -47,10 +47,18 @@ const getStepConfig = (file) => {
                 return; // Config was already resolved
             }
             else if (code !== 0) {
-                reject(new Error(`Process exited with code ${code}`));
+                reject(`Process exited with code ${code}`);
             }
             else if (!config) {
-                reject(new Error(`No config found for file ${file}`));
+                reject(`No config found for file ${file}`);
+            }
+        });
+        child.on('error', (error) => {
+            if (error.code === 'ENOENT') {
+                reject(`Executable ${command} not found`);
+            }
+            else {
+                reject(error);
             }
         });
     });

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

@@ -2,16 +2,19 @@ import { ZodObject } from 'zod';
 import { ApiRouteConfig, CronConfig, EventConfig, Flow, Step } from './types';
 import { Printer } from './printer';
 type FlowEvent = 'flow-created' | 'flow-removed' | 'flow-updated';
+type StepEvent = 'step-created' | 'step-removed' | 'step-updated';
 export declare class LockedData {
     readonly baseDir: string;
     flows: Record<string, Flow>;
     activeSteps: Step[];
     devSteps: Step[];
-    readonly printer: Printer;
+    printer: Printer;
     private stepsMap;
     private handlers;
+    private stepHandlers;
     constructor(baseDir: string);
     on(event: FlowEvent, handler: (flowName: string) => void): void;
+    onStep(event: StepEvent, handler: (step: Step) => void): void;
     eventSteps(): Step<EventConfig<ZodObject<any>>>[];
     apiSteps(): Step<ApiRouteConfig>[];
     cronSteps(): Step<CronConfig>[];

package/dist/src/locked-data.js

@@ -17,10 +17,18 @@ class LockedData {
             'flow-removed': [],
             'flow-updated': [],
         };
+        this.stepHandlers = {
+            'step-created': [],
+            'step-removed': [],
+            'step-updated': [],
+        };
     }
     on(event, handler) {
         this.handlers[event].push(handler);
     }
+    onStep(event, handler) {
+        this.stepHandlers[event].push(handler);
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     eventSteps() {
         return this.activeSteps.filter(guards_1.isEventStep);
@@ -72,6 +80,7 @@ class LockedData {
             }
         }
         savedStep.config = newStep.config;
+        this.stepHandlers['step-updated'].forEach((handler) => handler(newStep));
         this.printer.printStepUpdated(newStep);
         return true;
     }
@@ -96,6 +105,7 @@ class LockedData {
                 this.onFlowUpdated(flowName);
             }
         }
+        this.stepHandlers['step-created'].forEach((handler) => handler(step));
         this.printer.printStepCreated(step);
         return true;
     }
@@ -116,6 +126,7 @@ class LockedData {
                 this.onFlowUpdated(flowName);
             }
         }
+        this.stepHandlers['step-removed'].forEach((handler) => handler(step));
         this.printer.printStepRemoved(step);
     }
     createFlow(flowName) {

package/dist/src/logger.d.ts

@@ -1,14 +1,15 @@
 import { Server } from 'socket.io';
 export declare class BaseLogger {
+    readonly isVerbose: boolean;
     private readonly meta;
-    private logger;
-    constructor(meta?: Record<string, unknown>);
+    constructor(isVerbose?: boolean, meta?: Record<string, unknown>);
     child(meta?: Record<string, unknown>): this;
+    private _log;
     info(message: string, args?: unknown): void;
     error(message: string, args?: unknown): void;
     debug(message: string, args?: unknown): void;
     warn(message: string, args?: unknown): void;
-    log(args: unknown): void;
+    log(args: any): void;
 }
 export declare class Logger extends BaseLogger {
     private readonly traceId;
@@ -16,7 +17,7 @@ export declare class Logger extends BaseLogger {
     private readonly step;
     private readonly socketServer?;
     private emitLog;
-    constructor(traceId: string, flows: string[] | undefined, step: string, socketServer?: Server | undefined);
+    constructor(traceId: string, flows: string[] | undefined, step: string, isVerbose: boolean, socketServer?: Server | undefined);
     child(meta?: Record<string, unknown>): this;
     log(message: any): void;
     info: (message: string, args?: unknown) => void;

package/dist/src/logger.js

@@ -1,44 +1,51 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.globalLogger = exports.Logger = exports.BaseLogger = void 0;
-const pino_1 = __importDefault(require("pino"));
-const isDebugEnabled = () => process.env.LOG_LEVEL === 'debug';
+const pretty_print_1 = require("./pretty-print");
+const logLevel = process.env.LOG_LEVEL ?? 'info';
+const isDebugEnabled = logLevel === 'debug';
+const isInfoEnabled = ['info', 'debug'].includes(logLevel);
+const isWarnEnabled = ['warn', 'info', 'debug', 'trace'].includes(logLevel);
 class BaseLogger {
-    constructor(meta = {}) {
+    constructor(isVerbose = false, meta = {}) {
+        this.isVerbose = isVerbose;
         this.meta = meta;
-        this.logger = (0, pino_1.default)({
-            level: process.env.LOG_LEVEL || 'info',
-            formatters: { level: (level) => ({ level }) },
-            base: null,
-            mixin: () => meta,
-        });
     }
     child(meta = {}) {
-        return new BaseLogger({ ...this.meta, ...meta });
+        return new BaseLogger(this.isVerbose, { ...this.meta, ...meta });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    _log(level, msg, args) {
+        const time = Date.now();
+        (0, pretty_print_1.prettyPrint)({ level, time, msg, ...this.meta, ...(args ?? {}) }, !this.isVerbose);
     }
     info(message, args) {
-        this.logger.info(args, message);
+        if (isInfoEnabled) {
+            this._log('info', message, args);
+        }
     }
     error(message, args) {
-        this.logger.error(args, message);
+        this._log('error', message, args);
     }
     debug(message, args) {
-        this.logger.debug(args, message);
+        if (isDebugEnabled) {
+            this._log('debug', message, args);
+        }
     }
     warn(message, args) {
-        this.logger.warn(args, message);
+        if (isWarnEnabled) {
+            this._log('warn', message, args);
+        }
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(args) {
-        this.logger.info(args);
+        this._log('info', args.msg, args);
     }
 }
 exports.BaseLogger = BaseLogger;
 class Logger extends BaseLogger {
-    constructor(traceId, flows, step, socketServer) {
-        super({ traceId, flows, step });
+    constructor(traceId, flows, step, isVerbose, socketServer) {
+        super(isVerbose, { traceId, flows, step });
         this.traceId = traceId;
         this.flows = flows;
         this.step = step;
@@ -52,8 +59,8 @@ class Logger extends BaseLogger {
             this.emitLog('error', message, args);
         };
         this.debug = (message, args) => {
-            super.debug(message, args);
-            if (isDebugEnabled()) {
+            if (isDebugEnabled) {
+                super.debug(message, args);
                 this.emitLog('debug', message, args);
             }
         };
@@ -74,11 +81,11 @@ class Logger extends BaseLogger {
         };
     }
     child(meta = {}) {
-        return new Logger(this.traceId, this.flows, meta.step, this.socketServer);
+        return new Logger(this.traceId, this.flows, meta.step, this.isVerbose, this.socketServer);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     log(message) {
-        console.log(JSON.stringify(message));
+        super.log(message);
         this.emitLog(message.level, message.msg, message);
     }
 }

package/dist/src/pretty-print.d.ts

@@ -0,0 +1 @@
+export declare const prettyPrint: (json: Record<string, any>, excludeDetails?: boolean) => void;

package/dist/src/pretty-print.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prettyPrint = void 0;
+const colors_1 = __importDefault(require("colors"));
+const stepTag = (step) => colors_1.default.bold(colors_1.default.cyan(step));
+const timestampTag = (timestamp) => colors_1.default.gray(timestamp);
+const traceIdTag = (traceId) => colors_1.default.gray(traceId);
+const levelTags = {
+    error: colors_1.default.red('[ERROR]'),
+    info: colors_1.default.blue('[INFO]'),
+    warn: colors_1.default.yellow('[WARN]'),
+    debug: colors_1.default.gray('[DEBUG]'),
+    trace: colors_1.default.gray('[TRACE]'),
+};
+const numericTag = (value) => colors_1.default.green(value);
+const stringTag = (value) => colors_1.default.cyan(value);
+const booleanTag = (value) => colors_1.default.blue(value);
+const arrayBrackets = ['[', ']'].map((s) => colors_1.default.gray(s));
+const objectBrackets = ['{', '}'].map((s) => colors_1.default.gray(s));
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const prettyPrintObject = (obj, depth = 0, parentIsLast = false, prefix = '') => {
+    const tab = prefix + (depth === 0 ? '' : parentIsLast ? '│ ' : '│ ');
+    if (depth > 2) {
+        return `${tab} └ ${colors_1.default.gray('[...]')}`;
+    }
+    const entries = Object.entries(obj);
+    return entries
+        .map(([key, value], index) => {
+        const isLast = index === entries.length - 1;
+        const isObject = typeof value === 'object' && value !== null;
+        const prefix = isLast && !isObject ? '└' : '├';
+        if (isObject) {
+            const subObject = prettyPrintObject(value, depth + 1, isLast, tab);
+            const [start, end] = Array.isArray(value) ? arrayBrackets : objectBrackets;
+            return `${tab}${prefix} ${key}: ${start}\n${subObject}\n${tab}${isLast ? '└' : '│'} ${end}`;
+        }
+        let printedValue = value;
+        if (typeof value === 'number') {
+            printedValue = numericTag(String(value));
+        }
+        else if (typeof value === 'boolean') {
+            printedValue = booleanTag(String(value));
+        }
+        else if (typeof value === 'string') {
+            printedValue = stringTag(value);
+        }
+        return `${tab}${prefix} ${key}: ${printedValue}`;
+    })
+        .join('\n');
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const prettyPrint = (json, excludeDetails = false) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { time, traceId, msg, flows, level, step, ...details } = json;
+    const levelTag = levelTags[level];
+    const timestamp = timestampTag(`[${new Date(time).toLocaleTimeString()}]`);
+    const objectHasKeys = Object.keys(details).length > 0;
+    console.log(`${timestamp} ${traceIdTag(traceId)} ${levelTag} ${stepTag(step)} ${msg}`);
+    if (objectHasKeys && !excludeDetails) {
+        console.log(prettyPrintObject(details));
+    }
+};
+exports.prettyPrint = prettyPrint;

package/dist/src/printer.d.ts

@@ -3,6 +3,13 @@ import { Step } from './types';
 export declare class Printer {
     private readonly baseDir;
     constructor(baseDir: string);
+    stepTag: string;
+    flowTag: string;
+    created: string;
+    building: string;
+    built: string;
+    updated: string;
+    removed: string;
     printInvalidEmit(step: Step, emit: string): void;
     printStepCreated(step: Step): void;
     printStepUpdated(step: Step): void;
@@ -11,7 +18,19 @@ export declare class Printer {
     printFlowUpdated(flowName: string): void;
     printFlowRemoved(flowName: string): void;
     printValidationError(stepPath: string, validationError: ValidationError): void;
-    private getRelativePath;
-    private getStepType;
-    private getStepPath;
+    getRelativePath(filePath: string): string;
+    getStepType(step: Step): string;
+    getStepPath(step: Step): string;
+}
+export declare class NoPrinter extends Printer {
+    constructor(baseDir: string);
+    printInvalidEmit(): void;
+    printStepCreated(): void;
+    printStepUpdated(): void;
+    printStepRemoved(): void;
+    printFlowCreated(): void;
+    printFlowUpdated(): void;
+    printFlowRemoved(): void;
+    printStepType(): void;
+    printStepPath(): void;
 }

package/dist/src/printer.js

@@ -3,13 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Printer = void 0;
+exports.NoPrinter = exports.Printer = void 0;
 const colors_1 = __importDefault(require("colors"));
 const path_1 = __importDefault(require("path"));
 const guards_1 = require("./guards");
 const stepTag = colors_1.default.bold(colors_1.default.magenta('Step'));
 const flowTag = colors_1.default.bold(colors_1.default.blue('Flow'));
 const created = colors_1.default.green('➜ [CREATED]');
+const building = colors_1.default.yellow('⚡ [BUILDING]');
+const built = colors_1.default.green('✓ [BUILT]');
 const updated = colors_1.default.yellow('➜ [UPDATED]');
 const removed = colors_1.default.red('➜ [REMOVED]');
 const invalidEmit = colors_1.default.red('➜ [INVALID EMIT]');
@@ -17,6 +19,13 @@ const error = colors_1.default.red('[ERROR]');
 class Printer {
     constructor(baseDir) {
         this.baseDir = baseDir;
+        this.stepTag = stepTag;
+        this.flowTag = flowTag;
+        this.created = created;
+        this.building = building;
+        this.built = built;
+        this.updated = updated;
+        this.removed = removed;
     }
     printInvalidEmit(step, emit) {
         console.log(`${invalidEmit} ${stepTag} ${this.getStepType(step)} ${this.getStepPath(step)} tried to emit an event not defined in the step config: ${colors_1.default.yellow(emit)}`);
@@ -72,3 +81,18 @@ class Printer {
     }
 }
 exports.Printer = Printer;
+class NoPrinter extends Printer {
+    constructor(baseDir) {
+        super(baseDir);
+    }
+    printInvalidEmit() { }
+    printStepCreated() { }
+    printStepUpdated() { }
+    printStepRemoved() { }
+    printFlowCreated() { }
+    printFlowUpdated() { }
+    printFlowRemoved() { }
+    printStepType() { }
+    printStepPath() { }
+}
+exports.NoPrinter = NoPrinter;

package/dist/src/python/get-config.py

@@ -8,25 +8,41 @@ from typing import Any, Callable
 NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
 
 def sendMessage(text):
-  'sends a Node IPC message to parent proccess'
-  # encode message as json string + newline in bytes
-  bytesMessage = (json.dumps(text) + "\n").encode('utf-8')
-  # send message
-  os.write(NODEIPCFD, bytesMessage)
+    'sends a Node IPC message to parent proccess'
+    # encode message as json string + newline in bytes
+    bytesMessage = (json.dumps(text) + "\n").encode('utf-8')
+    # send message
+    os.write(NODEIPCFD, bytesMessage)
 
 async def run_python_module(file_path: str) -> None:
     try:
+        # Get the directory containing the module file
+        module_dir = os.path.dirname(os.path.abspath(file_path))
+        
+        # Add module directory to Python path
+        if module_dir not in sys.path:
+            sys.path.insert(0, module_dir)
+            
+        # Get the flows directory (parent of steps)
+        flows_dir = os.path.dirname(module_dir)
+        if flows_dir not in sys.path:
+            sys.path.insert(0, flows_dir)
+
         # Load the module dynamically
         spec = importlib.util.spec_from_file_location("dynamic_module", file_path)
         if spec is None or spec.loader is None:
             raise ImportError(f"Could not load module from {file_path}")
             
         module = importlib.util.module_from_spec(spec)
+        # Add module's directory as its __package__
+        module.__package__ = os.path.basename(module_dir)
         spec.loader.exec_module(module)
 
         # Print the config if it exists
         if hasattr(module, 'config'):
             sendMessage(module.config)
+        else:
+            raise AttributeError(f"No 'config' found in module {file_path}")
 
     except Exception as error:
         print('Error running Python module:', str(error), file=sys.stderr)

package/dist/src/python/python-runner.py

@@ -1,13 +1,12 @@
 import sys
 import json
 import importlib.util
-import traceback
-import asyncio
 import os
+import asyncio
+import traceback
 from logger import Logger
 from rpc import RpcSender
 from rpc_state_manager import RpcStateManager
-
 from typing import Any
 
 def parse_args(arg: str) -> Any:
@@ -33,22 +32,33 @@ class Context:
 
 async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
     try:
-        # Construct path relative to steps directory
-        flows_dir = os.path.join(os.getcwd(), 'steps')
-        module_path = os.path.join(flows_dir, file_path)
+        # Get the directory containing the module file
+        module_dir = os.path.dirname(os.path.abspath(file_path))
+        
+        # Add module directory to Python path
+        if module_dir not in sys.path:
+            sys.path.insert(0, module_dir)
+            
+        # Get the flows directory (parent of steps)
+        flows_dir = os.path.dirname(module_dir)
+        if flows_dir not in sys.path:
+            sys.path.insert(0, flows_dir)
+
         contextInFirstArg = args.contextInFirstArg
 
         # Load the module dynamically
-        spec = importlib.util.spec_from_file_location("dynamic_module", module_path)
+        spec = importlib.util.spec_from_file_location("dynamic_module", file_path)
         if spec is None or spec.loader is None:
-            raise ImportError(f"Could not load module from {module_path}")
+            raise ImportError(f"Could not load module from {file_path}")
             
         module = importlib.util.module_from_spec(spec)
+        # Add module's directory as its __package__
+        module.__package__ = os.path.basename(module_dir)
         spec.loader.exec_module(module)
 
         # Check if the handler function exists
         if not hasattr(module, 'handler'):
-            raise AttributeError(f"Function 'handler' not found in module {module_path}")
+            raise AttributeError(f"Function 'handler' not found in module {file_path}")
 
         context = Context(args, rpc)
 
@@ -57,13 +67,12 @@ async def run_python_module(file_path: str, rpc: RpcSender, args: Any) -> None:
         else:
             result = await module.handler(args.data, context)
 
-        if (result):
+        if result:
             await rpc.send('result', result)
 
         rpc.close()
-
-        # We need this to close the process
         rpc.send_no_wait('close', None)
+        
     except Exception as error:
         print(f'Error running Python module: {error}', file=sys.stderr)
         traceback.print_exc(file=sys.stderr)
@@ -79,7 +88,5 @@ if __name__ == "__main__":
 
     rpc = RpcSender()
     loop = asyncio.get_event_loop()
-    # Create and gather tasks
     tasks = asyncio.gather(rpc.init(), run_python_module(file_path, rpc, parse_args(arg)))
-    # Run until tasks complete
-    loop.run_until_complete(tasks)
+    loop.run_until_complete(tasks)

package/dist/src/server.d.ts

@@ -14,4 +14,8 @@ export type MotiaServer = {
     addRoute: (step: Step<ApiRouteConfig>) => void;
     cronManager: CronManager;
 };
-export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter) => Promise<MotiaServer>;
+type MotiaServerConfig = {
+    isVerbose: boolean;
+};
+export declare const createServer: (lockedData: LockedData, eventManager: EventManager, state: StateAdapter, config: MotiaServerConfig) => Promise<MotiaServer>;
+export {};

package/dist/src/server.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createServer = void 0;
 const cron_handler_1 = require("./cron-handler");
 const body_parser_1 = __importDefault(require("body-parser"));
-const crypto_1 = require("crypto");
 const express_1 = __importDefault(require("express"));
 const http_1 = __importDefault(require("http"));
 const socket_io_1 = require("socket.io");
@@ -15,18 +14,21 @@ const guards_1 = require("./guards");
 const logger_1 = require("./logger");
 const steps_1 = require("./steps");
 const call_step_file_1 = require("./call-step-file");
-const createServer = async (lockedData, eventManager, state) => {
+const LoggerFactory_1 = require("./LoggerFactory");
+const generate_trace_id_1 = require("./generate-trace-id");
+const createServer = async (lockedData, eventManager, state, config) => {
     const printer = lockedData.printer;
     const app = (0, express_1.default)();
     const server = http_1.default.createServer(app);
     const io = new socket_io_1.Server(server);
+    const loggerFactory = new LoggerFactory_1.LoggerFactory(config.isVerbose, io);
     const allSteps = [...steps_1.systemSteps, ...lockedData.activeSteps];
-    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, state, io);
+    const cronManager = (0, cron_handler_1.setupCronHandlers)(lockedData, eventManager, state, loggerFactory);
     const asyncHandler = (step) => {
         return async (req, res) => {
-            const traceId = (0, crypto_1.randomUUID)();
-            const { name, flows } = step.config;
-            const logger = new logger_1.Logger(traceId, flows, name, io);
+            const traceId = (0, generate_trace_id_1.generateTraceId)();
+            const { name: stepName, flows } = step.config;
+            const logger = loggerFactory.create({ traceId, flows, stepName });
             logger.debug('[API] Received request, processing step', { path: req.path });
             const request = {
                 body: req.body,

package/dist/src/step-handlers.js

@@ -38,11 +38,8 @@ const createStepHandlers = (lockedData, eventManager, state) => {
                         // eslint-disable-next-line @typescript-eslint/no-explicit-any
                     }
                     catch (error) {
-                        logger_1.globalLogger.error(`[step handler] error calling step`, {
-                            error: error.message,
-                            filePath,
-                            step: name,
-                        });
+                        const message = typeof error === 'string' ? error : error.message;
+                        logger.error(message);
                     }
                 },
             });

package/dist/src/step-validator.js

@@ -39,7 +39,7 @@ const emits = zod_1.z.array(zod_1.z.union([
     zod_1.z.string(),
     zod_1.z
         .object({
-        type: zod_1.z.string(),
+        topic: zod_1.z.string(),
         label: zod_1.z.string().optional(),
         conditional: zod_1.z.boolean().optional(),
     })

package/dist/src/steps/emit.step.js

@@ -11,17 +11,17 @@ exports.config = {
     emits: [], // Dynamic emissions
     flows: ['_system'],
     bodySchema: zod_1.z.object({
-        type: zod_1.z.string(),
+        topic: zod_1.z.string(),
         data: zod_1.z.record(zod_1.z.unknown()),
     }),
 };
 const handler = async (req, { emit, logger }) => {
-    const { type, data } = req.body;
-    logger.info('[Event Emitter] Emitting event', { type, data });
-    await emit({ type, data });
+    const { topic, data } = req.body;
+    logger.info('[Event Emitter] Emitting event', { topic, data });
+    await emit({ topic, data });
     return {
         status: 200,
-        body: { success: true, emitted: { type, data } },
+        body: { success: true, emitted: { topic, data } },
     };
 };
 exports.handler = handler;

package/dist/src/steps/emit.step.ts

@@ -10,19 +10,19 @@ export const config: ApiRouteConfig = {
   emits: [], // Dynamic emissions
   flows: ['_system'],
   bodySchema: z.object({
-    type: z.string(),
+    topic: z.string(),
     data: z.record(z.unknown()),
   }),
 }
 
 export const handler: StepHandler<typeof config> = async (req, { emit, logger }) => {
-  const { type, data } = req.body
+  const { topic, data } = req.body
 
-  logger.info('[Event Emitter] Emitting event', { type, data })
-  await emit({ type, data })
+  logger.info('[Event Emitter] Emitting event', { topic, data })
+  await emit({ topic, data })
 
   return {
     status: 200,
-    body: { success: true, emitted: { type, data } },
+    body: { success: true, emitted: { topic, data } },
   }
 }

package/dist/src/types.d.ts

@@ -7,7 +7,7 @@ export type InternalStateManager = {
     clear(traceId: string): Promise<void>;
 };
 export type EmitData = {
-    type: string;
+    topic: string;
     data: Record<string, unknown>;
 };
 export type Emitter = (event: EmitData) => Promise<void>;
@@ -19,7 +19,7 @@ export type FlowContext = {
 };
 export type EventHandler<TInput extends ZodObject<any>> = (input: z.infer<TInput>, ctx: FlowContext) => Promise<void>;
 export type Emit = string | {
-    type: string;
+    topic: string;
     label?: string;
     conditional?: boolean;
 };
@@ -78,7 +78,7 @@ export type CronConfig = {
 export type CronHandler = (ctx: FlowContext) => Promise<void>;
 export type StepHandler<T> = T extends EventConfig<any> ? EventHandler<T['input']> : T extends ApiRouteConfig ? ApiRouteHandler : T extends CronConfig ? CronHandler : never;
 export type Event<TData = unknown> = {
-    type: string;
+    topic: string;
     data: TData;
     traceId: string;
     flows?: string[];

package/dist/src/utils.js

@@ -2,16 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isAllowedToEmit = void 0;
 const guards_1 = require("./guards");
-const toType = (emit) => (typeof emit === 'string' ? emit : emit.type);
+const toTopic = (emit) => (typeof emit === 'string' ? emit : emit.topic);
 const isAllowedToEmit = (step, emit) => {
     if ((0, guards_1.isApiStep)(step)) {
-        return step.config.emits.map(toType).includes(emit);
+        return step.config.emits.map(toTopic).includes(emit);
     }
     if ((0, guards_1.isEventStep)(step)) {
-        return step.config.emits.map(toType).includes(emit);
+        return step.config.emits.map(toTopic).includes(emit);
     }
     if ((0, guards_1.isCronStep)(step)) {
-        return step.config.emits.map(toType).includes(emit);
+        return step.config.emits.map(toTopic).includes(emit);
     }
     return false;
 };

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@motiadev/core",
   "main": "dist/index.js",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "dependencies": {
     "body-parser": "^1.20.3",
     "colors": "^1.4.0",
     "express": "^4.21.2",
     "ioredis": "^5.4.2",
     "node-cron": "^3.0.3",
-    "pino": "^9.6.0",
     "socket.io": "^4.8.1",
     "ts-node": "^10.9.2",
     "tsconfig-paths": "^4.2.0",