@kadi.build/core 0.0.1-alpha.1 → 0.0.1-alpha.3

package/ipc.js

@@ -1,220 +0,0 @@
-import { EventEmitter } from 'events';
-import { randomUUID } from 'crypto';
-import { spawn } from 'child_process';
-import fs from 'fs';
-import { log } from 'console';
-
-//IPC JSON Message Schema
-// {
-//     type: 'launch' | 'shutdown' | 'message',
-//     contents: any,
-//     time: string
-// }
-
-export const IPCMessageBuilder = {
-  createMessage: function (type, contents) {
-    return JSON.stringify({
-      type: type,
-      contents: contents,
-      time: new Date().toISOString()
-    });
-  },
-
-  launch: function (commandString, logfilepath = null) {
-    return IPCMessageBuilder.createMessage('launch', {
-      command: commandString,
-      logfilepath: logfilepath
-    });
-  },
-
-  shutdown: function () {
-    return IPCMessageBuilder.createMessage('shutdown', {});
-  },
-
-  message: function (content) {
-    return IPCMessageBuilder.createMessage('message', content);
-  },
-
-  broker: function (content) {
-    return IPCMessageBuilder.createMessage('broker', content);
-  }
-};
-
-export const IPCManager = {
-  instances: new Map(),
-  IPCInterfaces: {},
-  createInstance: function (language, commandString, name = 'default') {
-    if (!IPCManager.IPCInterfaces[language]) {
-      throw new Error('Configuration for this language is not provided');
-    }
-
-    const instance = new IAbilityIPC(
-      language,
-      commandString,
-      IPCManager.IPCInterfaces,
-      name
-    );
-    this.instances.set(name, instance);
-
-    instance.on('shutdown', () => {
-      this.instances.delete(name);
-      console.log(`Instance ${name} removed after shutdown.`);
-    });
-
-    return instance;
-  },
-
-  getInstance: function (name) {
-    return this.instances.get(name);
-  },
-
-  shutdownInstance: function (name) {
-    const instance = this.instances.get(name);
-    if (instance) {
-      instance.shutdown();
-    }
-  },
-
-  setIPCInterfaces: function (interfaces) {
-    IPCManager.IPCInterfaces = interfaces;
-  }
-};
-
-class IAbilityIPC extends EventEmitter {
-  constructor(language, commandString, interfaces, name) {
-    super();
-    this.language = language;
-    this.process = null; // Process is initially null
-    this.commandString = commandString;
-    this.name = name;
-    this.input_buffer = '';
-    this.error_buffer = '';
-    this._broker = null; // Broker used for proxying messages
-
-    // Read configurations from agent.json
-    this.IPCInterfaces = interfaces;
-    this.ipcStartupCommand = this.IPCInterfaces[language]; // Command to start the language IPC
-
-    if (!this.ipcStartupCommand) {
-      throw new Error('Unsupported language or missing command configuration');
-    } else {
-      console.log('IPC Startup Command: ', this.ipcStartupCommand);
-      this.start();
-    }
-  }
-
-  start() {
-    // Starts the child process that handles IPC
-    this.process = spawn(this.ipcStartupCommand, {
-      shell: true
-    });
-
-    this.process.stdout.on('data', (data) => {
-      this.input_buffer += data.toString();
-      let boundary = this.input_buffer.indexOf('\n');
-      while (boundary !== -1) {
-        let message = this.input_buffer.substring(0, boundary).trim();
-        this.input_buffer = this.input_buffer.substring(boundary + 1);
-        if (message) {
-          try {
-            let msg = JSON.parse(message);
-            if (msg.type === 'shutdown') {
-              this.emit('shutdown');
-              if (this._broker) {
-                this._broker.ws.close();
-              }
-            } else if (msg.type === 'broker') {
-              this.emit('broker', msg);
-            } else {
-              this.emit('message', msg);
-            }
-            // this.emit('message', JSON.parse(message));
-          } catch (error) {
-            console.error('Error parsing JSON:', error.message);
-            console.error('Raw data received:', message);
-          }
-        }
-        boundary = this.input_buffer.indexOf('\n');
-      }
-    });
-
-    this.process.stderr.on('data', (data) => {
-      this.error_buffer += data.toString();
-      let boundary = this.error_buffer.indexOf('\n');
-      while (boundary !== -1) {
-        let message = this.error_buffer.substring(0, boundary).trim();
-        this.error_buffer = this.error_buffer.substring(boundary + 1);
-        if (message) {
-          try {
-            this.emit('error', JSON.parse(message));
-          } catch (error) {
-            console.error('Error parsing JSON:', error.message);
-            console.error('Raw data received:', message);
-          }
-        }
-        boundary = this.error_buffer.indexOf('\n');
-      }
-    });
-
-    this.process.on('exit', (code) => {
-      this.emit('exit', code);
-      // this.emit('shutdown', this);  // Emitting a shutdown event for the manager to catch
-    });
-
-    this.process.on('error', (error) => {
-      this.emit('error', error);
-    });
-
-    this.on('broker', (msg) => {
-      if (this._broker) {
-        this._broker.send(JSON.stringify(msg.contents));
-      } else {
-        console.error('No broker available to forward message to.');
-      }
-    });
-
-    this.on('message', (msg) => {
-      // console.log('Message received:', msg);
-    });
-  }
-
-  launch(logfilepath = null) {
-    // Send the command string to the language-specific IPC to launch the actual tool
-    let msg = IPCMessageBuilder.launch(this.commandString, logfilepath);
-    console.log('Sending launch message: ', msg);
-    this.sendMessage(msg);
-  }
-
-  sendMessage(message) {
-    if (this.process && this.process.stdin.writable) {
-      this.process.stdin.write(JSON.stringify(message) + '\n');
-    } else {
-      // throw new Error("Process is not running or stdin is not writable.");
-    }
-  }
-
-  shutdown() {
-    this.sendMessage(IPCMessageBuilder.shutdown());
-  }
-
-  attachBroker(broker) {
-    this._broker = broker;
-
-    this._broker.on('message', (data) => {
-      let msg = JSON.parse(data);
-      console.log('IPC Broker Message Recieved: ', msg);
-      this.sendMessage(IPCMessageBuilder.broker(msg));
-    });
-
-    this._broker.on('error', (error) => {
-      let msg = JSON.parse(error);
-
-      this.sendMessage(IPCMessageBuilder.broker(msg));
-    });
-
-    this._broker.on('close', () => {
-      this.shutdown();
-      // process.exit(0); // Exit the process when the WebSocket connection is closed
-    });
-  }
-}

package/ipcInterfaces/pythonAbilityIPC.py

@@ -1,177 +0,0 @@
-import sys
-import json
-import subprocess
-import select
-import threading
-import os
-from datetime import datetime, timezone
-
-class MessageBuilder:
-    @staticmethod
-    def create_message(type, contents):
-        return json.dumps({
-            "type": type,
-            "contents": contents,
-            "time": datetime.now(timezone.utc).isoformat()
-        })
-
-    @staticmethod
-    def shutdown():
-        return MessageBuilder.create_message('shutdown', {})
-
-    @staticmethod
-    def message(contents):
-        return MessageBuilder.create_message('message', contents)
-    
-    @staticmethod
-    def broker(contents):
-        return MessageBuilder.create_message('broker', contents)
-
-def handle_process_output(ipc_instance, output):
-    """Developer-customizable function to handle stdout data."""
-    # print("Process Output:", output.strip())
-    # ipc_instance.send(MessageBuilder.message({"status": "stdout", "contents": output}))
-
-def handle_process_errors(ipc_instance, output):
-    """Developer-customizable function to handle stderr data."""
-    # print("Process Error:", output.strip())
-    ipc_instance.send(MessageBuilder.message({"status": "stderr", "contents": output}))
-
-def handle_broker(ipc_instance, contents):
-    """Developer-customizable function to handle custom Broker messages."""
-    # ipc_instance.send(MessageBuilder.broker({"status": "message_received", "contents": contents}))
-
-def handle_message(ipc_instance, contents):
-    """Developer-customizable function to handle custom IPC messages."""
-    # Placeholder implementation that simply prints the message
-    # print(f"Received custom message: {contents}")
-    # ipc_instance.send(MessageBuilder.message({"status": "message_received", "contents": contents}))
-    # Developers can add their own logic here depending on their requirements
-
-class PythonAbilityIPC:
-    def __init__(self):
-        self.running = True
-        self.child_process = None
-        self.logfile = False
-
-    def process_stream(self, stream, handler):
-        """Generic method to process stdout or stderr from child process."""
-        for line in iter(stream.readline, ''):
-            handler(line)
-        stream.close()
-
-    def read_input(self):
-        """Read input lines from stdin and process each as a JSON message."""
-        while self.running:
-            try:
-                readable, _, _ = select.select([sys.stdin], [], [], 0.1)
-                if readable:
-                    line = sys.stdin.readline()
-                    if line == '':
-                        print("Node.js process has terminated or closed the pipe.")
-                        self.shutdown()
-                        break
-                    if line.strip():
-                        try:
-                            message = json.loads(line)
-                            # self.send(MessageBuilder.message({"debug": "Parsing Message", "message": message}))
-                            self.parse_message(message)
-                        except json.JSONDecodeError as e:
-                            self.send_error(f"JSON decoding failed: {str(e)}")
-            except Exception as e:
-                self.send_error(f"An unexpected error occurred: {str(e)}")
-                self.shutdown()
-                break
-
-    def parse_message(self, message):
-        """Parse incoming messages and take appropriate actions."""
-        try:
-            message = json.loads(message)
-            message_type = message.get('type')
-            if message_type == 'launch':
-                command = message.get('contents').get('command')
-                logfilepath = message.get('contents').get('logfilepath', None)
-                self.launch_tool(command, logfilepath)
-            elif message_type == 'shutdown':
-                self.shutdown()
-            elif message_type == 'broker':
-                handle_broker(self, message.get('contents'))  # Handle broker messages
-            elif message_type == 'message':
-                handle_message(self, message.get('contents'))  # Handle ipc messages
-            else:
-                self.send(MessageBuilder.message({"status": "unknown_message_type", "contents": message}))
-        except Exception as e:
-            self.send_error(f"An error occurred: {e}")
-
-    def handle_stdout(self, output):
-        """Handles stdout from the child process."""
-        if self.logfile and self.stdout_log_path:
-            with open(self.stdout_log_path, 'a') as f:
-                f.write(output)
-        handle_process_output(self, output)
-
-    def handle_stderr(self, output):
-        """Handles stderr from the child process."""
-        if self.logfile and self.stderr_log_path:
-            with open(self.stderr_log_path, 'a') as f:
-                f.write(output)
-        handle_process_errors(self, output)
-
-    def launch_tool(self, command_string, logfilepath=None):
-        if self.child_process:
-            self.child_process.terminate()
-
-        if logfilepath:
-            self.logfile = True
-            timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
-            self.stdout_log_path = os.path.join(logfilepath, f"{timestamp}-stdout.log")
-            self.stderr_log_path = os.path.join(logfilepath, f"{timestamp}-stderr.log")
-            os.makedirs(logfilepath, exist_ok=True)
-
-        self.child_process = subprocess.Popen(
-            command_string, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            universal_newlines=True, bufsize=1
-        )
-        # Setup stdout and stderr handling threads
-        threading.Thread(target=self.process_stream, args=(self.child_process.stdout, self.handle_stdout)).start()
-        threading.Thread(target=self.process_stream, args=(self.child_process.stderr, self.handle_stderr)).start()
-
-        # Send a message back to KADI using the message builder
-        self.send(MessageBuilder.message({"status": "tool_launched", "command": command_string}))
-
-    def shutdown(self):
-        if self.child_process:
-            self.child_process.terminate()
-            self.child_process = None
-        self.running = False
-        self.send(MessageBuilder.shutdown())
-        sys.exit(0)
-
-    def send_error(self, message):
-        sys.stderr.write(MessageBuilder.message({
-            'type': 'error',
-            'contents': {'message': message, 'type': 'exception'},
-            'time': datetime.now(timezone.utc).isoformat()
-        }) + '\n')
-        sys.stderr.flush()
-
-    def send(self, serializedJSONmessage):
-        """Send a JSON message back to Node.js using standardized format."""
-        sys.stdout.write(serializedJSONmessage + '\n')
-        sys.stdout.flush()
-
-def main():
-    try:
-        ipc = PythonAbilityIPC()
-        ipc.read_input()
-    except Exception as e:
-        # Print exception information to stderr to catch it in Node.js
-        print(json.dumps({'type': 'error', 'contents': {'message': str(e), 'type': 'exception'}, 'time': datetime.now(timezone.utc).isoformat()}), file=sys.stderr)
-        # Here you could also include more sophisticated error handling mechanisms:
-        # - Logging to a file
-        # - Sending alerts to a monitoring system
-        # - Cleanup resources or attempt recovery
-        sys.exit(1)  # Exit with a non-zero status to indicate an error
-
-if __name__ == "__main__":
-    main()