@motiadev/core 0.0.1

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

@@ -0,0 +1,73 @@
+import sys
+import json
+import importlib.util
+import traceback
+import os
+from logger import Logger
+from rpc import RpcSender
+from rpc_state_manager import RpcStateManager
+
+from typing import Any
+
+def parse_args(arg: str) -> Any:
+    from types import SimpleNamespace
+    
+    try:
+        return json.loads(arg, object_hook=lambda d: SimpleNamespace(**d))
+    except json.JSONDecodeError:
+        print('Error parsing args:', arg)
+        return arg
+
+class Context:
+    def __init__(self, args: Any, file_name: str):
+        self.trace_id = args.traceId
+        self.flows = args.flows
+        self.file_name = file_name
+        self.sender = RpcSender()
+        self.state = RpcStateManager(self.sender)
+        self.logger = Logger(self.trace_id, self.flows, self.file_name, self.sender)
+
+    async def emit(self, event: Any):
+        await self.sender.send('emit', event)
+
+async def run_python_module(file_path: str, 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)
+
+        # Load the module dynamically
+        spec = importlib.util.spec_from_file_location("dynamic_module", module_path)
+        if spec is None or spec.loader is None:
+            raise ImportError(f"Could not load module from {module_path}")
+            
+        module = importlib.util.module_from_spec(spec)
+        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}")
+
+        context = Context(args, file_path)
+        context.sender.init()
+        
+        await module.handler(args.data, context)
+        
+        # exit with 0 to indicate success
+        sys.exit(0)
+    except Exception as error:
+        print('Error running Python module:', file=sys.stderr)
+
+        traceback.print_exc(file=sys.stderr)
+        sys.exit(1)
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print('Usage: python pythonRunner.py <file-path> <arg>', file=sys.stderr)
+        sys.exit(1)
+
+    file_path = sys.argv[1]
+    arg = sys.argv[2] if len(sys.argv) > 2 else None
+
+    import asyncio
+    asyncio.run(run_python_module(file_path, parse_args(arg)))

package/dist/src/python/rpc.py

@@ -0,0 +1,80 @@
+import uuid
+import asyncio
+import os
+import json
+import sys
+from typing import Any, Dict, Tuple
+
+# get the FD from ENV
+NODEIPCFD = int(os.environ["NODE_CHANNEL_FD"])
+
+class RpcSender:
+    def __init__(self):
+        self.pending_requests: Dict[str, Tuple[asyncio.Future, str, Any]] = {}
+
+    def send_no_wait(self, method: str, args: Any) -> None:
+        request = {
+            'type': 'rpc_request',
+            'method': method,
+            'args': args
+        }
+        # encode message as json string + newline in bytes
+        bytesMessage = (json.dumps(request) + "\n").encode('utf-8')
+        # send message
+        os.write(NODEIPCFD, bytesMessage)
+
+    async def send(self, method: str, args: Any) -> Any:
+        future = asyncio.Future()
+        request_id = str(uuid.uuid4())
+        self.pending_requests[request_id] = (future, method, args)
+
+        request = {
+            'type': 'rpc_request',
+            'id': request_id,
+            'method': method,
+            'args': args
+        }
+        # encode message as json string + newline in bytes
+        bytesMessage = (json.dumps(request) + "\n").encode('utf-8')
+        # send message
+        os.write(NODEIPCFD, bytesMessage)
+
+        return future
+
+    def init(self):
+        def on_message(msg: Dict[str, Any]):
+            if msg.get('type') == 'rpc_response':
+                request_id = msg['id']
+
+                if request_id in self.pending_requests:
+                    future, _, _ = self.pending_requests[request_id]
+
+                    if msg.get('error'):
+                        future.set_exception(msg['error'])
+                    elif msg.get('result'):
+                        future.set_result(msg['result'])
+                    else:
+                        # It's a void response
+                        future.set_result(None)
+
+                    del self.pending_requests[request_id]
+
+        # Read messages from Node IPC file descriptor
+        async def read_messages():
+            while True:
+                # Read message from pipe
+                message = os.read(NODEIPCFD, 4096).decode('utf-8')
+                if not message:
+                    continue
+                    
+                # Parse messages (may be multiple due to buffering)
+                for line in message.splitlines():
+                    if line:
+                        try:
+                            msg = json.loads(line)
+                            on_message(msg)
+                        except json.JSONDecodeError:
+                            pass
+
+        # Start message reading loop
+        asyncio.create_task(read_messages())

package/dist/src/python/rpc_state_manager.py

@@ -0,0 +1,18 @@
+from typing import Any
+
+
+class RpcStateManager:
+    def __init__(self, sender):
+        self.sender = sender
+
+    async def get(self, trace_id: str, key: str) -> Any:
+        return await self.sender.send('state.get', {'traceId': trace_id, 'key': key})
+
+    async def set(self, trace_id: str, key: str, value: Any) -> None:
+        await self.sender.send('state.set', {'traceId': trace_id, 'key': key, 'value': value})
+
+    async def delete(self, trace_id: str, key: str) -> None:
+        await self.sender.send('state.delete', {'traceId': trace_id, 'key': key})
+
+    async def clear(self, trace_id: str) -> None:
+        await self.sender.send('state.clear', {'traceId': trace_id})

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

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

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

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRubyConfig = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../logger");
+const getRubyConfig = (file) => {
+    const getConfig = path_1.default.join(__dirname, 'get_config.rb');
+    return new Promise((resolve, reject) => {
+        let config = null;
+        const child = (0, child_process_1.spawn)('ruby', [getConfig, file], {
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+        });
+        child.on('message', (message) => {
+            logger_1.globalLogger.debug('[Ruby Config] Read config', { config: message });
+            config = message;
+        });
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(`Process exited with code ${code}`));
+            }
+            else if (!config) {
+                reject(new Error(`No config found for file ${file}`));
+            }
+            else {
+                resolve(config);
+            }
+        });
+    });
+};
+exports.getRubyConfig = getRubyConfig;

package/dist/src/ruby/get_config.rb

@@ -0,0 +1,78 @@
+require 'json'
+
+# Get the FD from ENV with a default fallback for testing
+NODEIPCFD = (ENV['NODE_CHANNEL_FD'] || 1).to_i
+
+def send_message(message)
+  begin
+    io = IO.new(NODEIPCFD, 'w')
+    json_message = message.to_json + "\n"
+    io.write(json_message)
+    io.flush
+  rescue Errno::EBADF => e
+    warn "Error writing to IPC channel: #{e.message}"
+    exit(1)
+  ensure
+    io.close if io && !io.closed?
+  end
+end
+
+def extract_config(file_path)
+  begin
+    # Remove previous Config class if it exists
+    Object.send(:remove_const, :Config) if Object.const_defined?(:Config)
+    
+    # Create a new binding for evaluation
+    evaluation_binding = binding
+    
+    # Load and evaluate the file content in our binding
+    file_content = File.read(file_path)
+    evaluation_binding.eval(file_content)
+    
+    # Get the config variable from our binding
+    config = evaluation_binding.eval('config')
+    
+    # Convert config instance to hash with symbol keys
+    {
+      type: config.type,
+      name: config.name,
+      subscribes: config.subscribes,
+      emits: config.emits,
+      input: config.input,
+      flows: config.flows
+    }
+  rescue NameError => e
+    raise "Error accessing config: #{e.message}"
+  rescue => e
+    raise "Error processing config file: #{e.message}"
+  end
+end
+
+# Main execution block
+begin
+  if ARGV.empty?
+    warn 'Error: No file path provided'
+    exit(1)
+  end
+
+  file_path = ARGV[0]
+  
+  unless File.exist?(file_path)
+    warn "Error: File not found: #{file_path}"
+    exit(1)
+  end
+  
+  unless File.readable?(file_path)
+    warn "Error: File is not readable: #{file_path}"
+    exit(1)
+  end
+
+  # Extract and send config
+  config = extract_config(file_path)
+  send_message(config)
+  
+  exit(0)
+rescue => e
+  warn "Error: #{e.message}"
+  exit(1)
+end

package/dist/src/ruby/logger.rb

@@ -0,0 +1,55 @@
+require 'json'
+require 'time'
+
+class CustomLogger
+  def initialize(trace_id, flows, file_path)
+    @trace_id = trace_id
+    @flows = flows
+    @file_name = File.basename(file_path)
+  end
+
+  def log(level, message, args = nil)
+    # Ensure message is not nested JSON or a stringified JSON object
+    if message.is_a?(String) && message.strip.start_with?('{', '[')
+      begin
+        message = JSON.parse(message) # Parse if valid JSON
+      rescue JSON::ParserError
+        # Leave message as is if it's not valid JSON
+      end
+    end
+
+    # Construct the base log entry
+    log_entry = {
+      msg: message
+    }
+
+    # Merge additional arguments if provided
+    if args
+      args = case args
+             when OpenStruct then args.to_h
+             when Hash then args
+             else { data: args }
+             end
+      log_entry.merge!(args)
+    end
+
+    # Generate JSON output
+    puts JSON.dump(log_entry)
+  end
+
+  def info(message, args = nil)
+    log('info', message, args)
+  end
+
+  def error(message, args = nil)
+    log('error', message, args)
+  end
+
+  def debug(message, args = nil)
+    log('debug', message, args)
+  end
+
+  def warn(message, args = nil)
+    log('warn', message, args)
+  end
+end

package/dist/src/ruby/ruby_runner.rb

@@ -0,0 +1,80 @@
+require 'json'
+require 'io/console'
+require 'ostruct'
+require 'pathname'
+require_relative 'logger'
+require_relative 'state_adapter'
+
+# Parse arguments as JSON or fallback to raw string
+def parse_args(arg)
+  begin
+    JSON.parse(arg, object_class: OpenStruct)
+  rescue JSON::ParserError
+    puts "Error parsing args: #{arg}"
+    arg
+  end
+end
+
+# Get the file descriptor from ENV
+NODE_CHANNEL_FD = ENV['NODE_CHANNEL_FD'].to_i
+
+# Context class for managing the execution environment
+class Context
+  attr_reader :trace_id, :flows, :file_name, :state, :logger
+
+  # Emit a message to the parent process via Node IPC
+  def emit(text)
+    message = (JSON.dump(text) + "\n").encode('utf-8')
+    IO.new(NODE_CHANNEL_FD, 'w').write(message)
+  end
+
+  def initialize(args, file_name)
+    @trace_id = args.traceId
+    @flows = args.flows
+    @file_name = file_name
+    @state = create_internal_state_manager(state_manager_url: args[:stateConfig]&.dig(:stateManagerUrl))
+    @logger = CustomLogger.new(@trace_id, @flows, @file_name)
+  end
+end
+
+# Dynamically load and execute a Ruby script
+def run_ruby_module(file_path, args)
+  unless File.exist?(file_path)
+    raise LoadError, "Could not load module from #{file_path}"
+  end
+
+  # Load the file dynamically
+  load file_path
+
+  unless defined?(executor)
+    raise NameError, "Function 'executor' not found in module #{file_path}"
+  end
+
+  context = Context.new(args, file_path)
+
+  executor(args.data, context)
+rescue => e
+  $stderr.puts "Error running Ruby module: #{e.message}"
+  $stderr.puts e.backtrace
+  exit 1
+end
+
+# Entry point
+if __FILE__ == $PROGRAM_NAME
+  if ARGV.length < 1
+    $stderr.puts 'Usage: ruby ruby-runner.rb <file-path> <arg>'
+    exit 1
+  end
+
+  file_path = ARGV[0]
+  arg = ARGV[1] || nil
+
+  begin
+    parsed_args = parse_args(arg)
+    run_ruby_module(file_path, parsed_args)
+  rescue => e
+    $stderr.puts "Error: #{e.message}"
+    $stderr.puts e.backtrace
+    exit 1
+  end
+end

package/dist/src/ruby/state_adapter.rb

@@ -0,0 +1,62 @@
+require 'net/http'
+require 'json'
+require 'uri'
+require 'logger'
+
+class StateManagerError < StandardError; end
+
+LOGGER = Logger.new($stdout)
+
+def get_state_manager_handler(state_manager_url)
+  lambda do |action, payload|
+    begin
+      uri = URI("#{state_manager_url}/#{action}")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      request['x-trace-id'] = payload[:traceId]
+      # TODO: Add internal auth token for security
+      # TODO: Encrypt the payload for security
+      request.body = payload.to_json
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.request(request)
+      end
+
+      unless response.is_a?(Net::HTTPSuccess)
+        error_message = "Failed posting state change: #{response.code} - #{response.message}"
+        LOGGER.error(error_message)
+        raise StateManagerError, error_message
+      end
+
+      if action == 'get'
+        result = JSON.parse(response.body, object_class: OpenStruct)
+        return result.data
+      end
+
+      nil
+    rescue StandardError => error
+      LOGGER.error("[internal state manager] failed posting state change: #{error.message}")
+      raise StateManagerError, "Failed posting state change: #{error.message}"
+    end
+  end
+end
+
+def create_internal_state_manager(state_manager_url:)
+  handler = get_state_manager_handler(state_manager_url)
+
+  {
+    get: ->(trace_id, key) { 
+      result = handler.call('get', { traceId: trace_id, key: key })
+      { data: result }
+    },
+    set: ->(trace_id, key, value) { 
+      handler.call('set', { traceId: trace_id, key: key, value: value })
+    },
+    delete: ->(trace_id, key) { 
+      handler.call('delete', { traceId: trace_id, key: key })
+    },
+    clear: ->(trace_id) {
+      handler.call('clear', { traceId: trace_id })
+    }
+  }
+end

package/dist/src/server.d.ts

@@ -0,0 +1,18 @@
+import { Express } from 'express';
+import http from 'http';
+import { Server as SocketIOServer } from 'socket.io';
+import { StateAdapter } from './state/state-adapter';
+import { EventManager, LockedData, Step } from './types';
+type ServerOptions = {
+    steps: Step[];
+    flows: LockedData['flows'];
+    eventManager: EventManager;
+    state: StateAdapter;
+};
+type ServerOutput = {
+    app: Express;
+    server: http.Server;
+    socketServer: SocketIOServer;
+};
+export declare const createServer: (options: ServerOptions) => Promise<ServerOutput>;
+export {};

package/dist/src/server.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServer = void 0;
+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");
+const flows_endpoint_1 = require("./flows-endpoint");
+const guards_1 = require("./guards");
+const logger_1 = require("./logger");
+const createServer = async (options) => {
+    const { flows, steps, eventManager, state } = options;
+    const app = (0, express_1.default)();
+    const server = http_1.default.createServer(app);
+    const io = new socket_io_1.Server(server);
+    const asyncHandler = (step, flows) => {
+        return async (req, res) => {
+            const traceId = (0, crypto_1.randomUUID)();
+            const logger = new logger_1.Logger(traceId, flows, step.config.name, io);
+            logger.debug('[API] Received request, processing step', { path: req.path, step });
+            const module = require(step.filePath);
+            const handler = module.handler;
+            const request = {
+                body: req.body,
+                headers: req.headers,
+                pathParams: req.params,
+                queryParams: req.query,
+            };
+            const emit = async ({ data, type }) => {
+                await eventManager.emit({ data, type, traceId, flows, logger }, step.filePath);
+            };
+            try {
+                const result = await handler(request, { emit, state, logger, traceId });
+                if (result.headers) {
+                    Object.entries(result.headers).forEach(([key, value]) => res.setHeader(key, value));
+                }
+                res.status(result.status);
+                res.json(result.body);
+            }
+            catch (error) {
+                logger.error('[API] Internal server error', { error });
+                console.log(error);
+                res.status(500).json({ error: 'Internal server error' });
+            }
+        };
+    };
+    app.use(body_parser_1.default.json());
+    app.use(body_parser_1.default.urlencoded({ extended: true }));
+    const apiSteps = steps.filter(guards_1.isApiStep);
+    for (const step of apiSteps) {
+        const { method, flows, path } = step.config;
+        logger_1.globalLogger.debug('[API] Registering route', step.config);
+        if (method === 'POST') {
+            app.post(path, asyncHandler(step, flows));
+        }
+        else if (method === 'GET') {
+            app.get(path, asyncHandler(step, flows));
+        }
+        else {
+            throw new Error(`Unsupported method: ${method}`);
+        }
+    }
+    (0, flows_endpoint_1.flowsEndpoint)(flows, app);
+    server.on('error', (error) => {
+        console.error('Server error:', error);
+    });
+    return { app, server, socketServer: io };
+};
+exports.createServer = createServer;

package/dist/src/state/adapters/default-state-adapter.d.ts

@@ -0,0 +1,17 @@
+import { StateAdapter } from '../state-adapter';
+export type FileAdapterConfig = {
+    filePath: string;
+};
+export declare class FileStateAdapter implements StateAdapter {
+    private filePath;
+    constructor(config: FileAdapterConfig);
+    init(): Promise<void>;
+    get(traceId: string, key: string): Promise<any>;
+    set(traceId: string, key: string, value: any): Promise<void>;
+    delete(traceId: string, key: string): Promise<void>;
+    clear(traceId: string): Promise<void>;
+    cleanup(): Promise<void>;
+    private _makeKey;
+    private _readFile;
+    private _writeFile;
+}