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

package/README.md

@@ -1,306 +1,1235 @@
 # @kadi.build/core
 
----
+> A comprehensive toolkit for building and managing KADI abilities with multiple transport protocols
+
+[![npm version](https://img.shields.io/npm/v/@kadi.build/core.svg)](https://www.npmjs.com/package/@kadi.build/core)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+## 🎯 Overview
+
+`@kadi.build/core` is the foundational library for creating KADI abilities - modular, protocol-agnostic services that can communicate via multiple transport layers. Whether you're building local tools, distributed microservices, or high-performance native modules, this toolkit provides a unified, developer-friendly API that abstracts away transport complexity.
+
+## 📚 Table of Contents
+
+- [🎯 Overview](#-overview)
+- [📦 Installation](#-installation)
+- [🚀 Quick Start](#-quick-start)
+- [🔌 Transport Protocols](#-transport-protocols)
+- [🛠️ Creating Abilities](#-creating-abilities)
+- [🔄 Architecture Deep Dive](#-architecture-deep-dive)
+- [📥 Loading Abilities](#-loading-abilities)
+- [⚙️ Configuration](#-configuration)
+- [🚀 Advanced Usage](#-advanced-usage)
+- [🔧 Development Workflow](#-development-workflow)
+- [📖 API Reference](#-api-reference)
+- [🎮 Running the Examples](#-running-the-examples)
+- [💡 Additional Examples](#-additional-examples)
+- [🐛 Troubleshooting](#-troubleshooting)
+- [🤝 Contributing](#-contributing)
+- [📄 License](#-license)
+- [🔗 Related Projects](#-related-projects)
+- [📚 Resources](#-resources)
+
+## 📦 Installation
+
+```bash
+npm install @kadi.build/core
+```
+
+For global CLI tools:
+
+```bash
+npm install -g @kadi.build/cli
+```
+
+## 🚀 Quick Start
 
-The `@kadi.build/core` module is a comprehensive toolkit for developers integrating with the KADI infrastructure. This module simplifies tasks such as managing `agent.json` files, spawning processes, interacting with brokers, and handling interprocess communication (IPC).
+### Creating Your First Ability
 
-## Features
+```javascript
+#!/usr/bin/env node
+import { KadiAbility } from '@kadi.build/core';
+
+// Create an ability instance
+const mathAbility = new KadiAbility({
+  name: 'math-ability',
+  version: '1.0.0',
+  description: 'Simple math operations'
+});
+
+// Register a method
+mathAbility.method('add', async ({ a, b }) => {
+  return { result: a + b };
+});
+
+// Start serving requests
+mathAbility.serve().catch(console.error);
+```
+
+### Loading and Using Abilities
 
-- **Agent JSON Management**: Manage configurations for tools, agents, or systems using KADI.
-- **Process Management**: Support launching and managing subprocesses.
-- **Multi-Broker Support**: Dynamic broker selection and management with environment/runtime configuration.
-- **Broker Interaction**: Facilitate communications with WebSocket brokers.
-- **IPC Support**: Tools for interprocess communication across various programming languages.
+```javascript
+import { loadAbility } from '@kadi.build/core';
 
-## Installation
+async function main() {
+  // Load an ability (uses first interface defined in agent.json)
+  const math = await loadAbility('math-ability');
 
-Install `@kadi.build/core` using npm:
+  // Call methods like regular functions
+  const result = await math.add({ a: 5, b: 3 });
+  console.log(result); // { result: 8 }
+
+  // List available methods
+  console.log(math.__list()); // ['add']
+}
+
+main().catch(console.error);
+```
+
+## 🔌 Transport Protocols
+
+KADI abilities support three transport protocols, each optimized for different use cases:
+
+### 1. Native Protocol (Fastest)
+
+- **Use Case**: High-performance, in-process execution
+- **How it Works**: Loads abilities as ES modules, enabling direct function calls
+- **Performance**: Zero IPC overhead - functions run in the same process
+- **Best For**: Utility libraries, data processing, performance-critical operations
+
+```javascript
+// Loads as native module by default if available
+const ability = await loadAbility('my-ability', 'native');
+```
+
+### 2. Stdio Protocol (Balanced)
+
+- **Use Case**: Language-agnostic local execution
+- **How it Works**: Spawns abilities as child processes, communicates via LSP-style JSON-RPC over stdin/stdout
+- **Performance**: Minimal overhead, reliable local IPC
+- **Best For**: Python scripts, Go binaries, Node.js services, development/testing
+
+```javascript
+// Force stdio protocol
+const ability = await loadAbility('my-ability', 'stdio');
+```
+
+**Environment Variables Passed to Child Process:**
 
 ```bash
-npm install @kadi.build/core
+KADI_PROTOCOL=stdio  # Identifies the protocol being used
+# Plus all parent process.env variables
 ```
 
-## Documentation
+### 3. Broker Protocol (Distributed)
 
-### Agent JSON Functions
+- **Use Case**: Distributed services, containerized deployments
+- **How it Works**: Abilities connect to a WebSocket broker for network communication
+- **Performance**: Network overhead, but enables scaling and distribution
+- **Best For**: Microservices, cloud deployments, load-balanced services
 
-- **`getAbilityJSON(abilityName, abilityVersion)`**: Retrieves the `agent.json` for a specified ability.
-- **`getAbilityJSONPath(abilityName, abilityVersion)`**: Provides the file path to the `agent.json` for a specific ability.
-- **`getAbilityVersionFromArray(abilities, name)`**: Searches ability array provided, and returns the version number for name provided.
-- **`getAbilitiesDir()`**: Returns the directory path where abilities are stored.
-- **`getProjectJSON()`**: Fetches the `agent.json` for the current project.
-- **`getProjectJSONPath()`**: Gets the file path for the project's `agent.json`.
-- **`getKadiCoreJSON()`**: Retrieves the `agent.json` for the Kadi core.
-- **`getKadiCoreJSONPath()`**: Provides the file path to the Kadi core's `agent.json`.
-- **`getKadiJSON()`**: Fetches the `agent.json` for the Kadi system.
-- **`getKadiJSONPath()`**: Returns the file path for the Kadi system's `agent.json`.
+```javascript
+// Use broker for distributed execution
+const ability = await loadAbility('my-ability', 'broker');
+```
 
-### Broker Management Functions
+**Environment Variables Passed to Child Process:**
 
-The broker management system allows dynamic selection from multiple configured brokers defined in `agent.json`:
+```bash
+KADI_PROTOCOL=broker                        # Identifies the protocol
+KADI_BROKER_URL=ws://localhost:8080        # Broker connection URL
+KADI_SERVICE_NAME=ability.echo.1_0_0       # Service identifier
+KADI_AGENT_SCOPE=uuid-here                 # Agent's scope/namespace
+# Plus all parent process.env variables
+```
+
+**Scope/Namespace Visibility:**
+
+The `KADI_AGENT_SCOPE` environment variable represents the agent's namespace. For the ability to be visible to its parent agent via the broker, it must register with the same scope:
+
+```javascript
+// In your ability code:
+const echoAbility = new KadiAbility({
+  name: 'echo-js',
+  version: '0.0.1',
+  description: 'Echo ability with broker support',
+  scope: process.env.KADI_AGENT_SCOPE // Use agent's scope for visibility
+});
+
+// Without this, the ability would only be visible in the 'global' scope
+// and the parent agent wouldn't be able to communicate with it
+```
+
+### Protocol Selection Strategy
+
+When no protocol is specified, `loadAbility` uses the **first interface** defined in the ability's `agent.json`. The KADI team recommends ordering interfaces from fastest to slowest (native → stdio → broker) for optimal default performance.
+
+```mermaid
+graph TD
+    A[Load Ability] --> B{Protocol Specified?}
+    B -->|Yes| C[Use Specified Protocol]
+    B -->|No| D{Check agent.json interfaces}
+    D --> E[Use First Interface Listed]
+    E --> F[native/stdio/broker]
+```
+
+**Recommended Interface Order in agent.json:**
 
 ```json
 {
-  "brokers": {
-    "local": "ws://127.0.0.1:8080",
-    "remote": "ws://production.example.com:8080",
-    "staging": "ws://staging.example.com:8080"
+  "interfaces": {
+    "native": { "entry": "service.js" }, // 1st choice: Fastest
+    "stdio": { "discover": true }, // 2nd choice: Balanced
+    "broker": { "discover": true } // 3rd choice: Distributed
   }
 }
 ```
 
-Available functions:
+## 🛠️ Creating Abilities
+
+### Basic Ability Structure
+
+```javascript
+import { KadiAbility } from '@kadi.build/core';
+
+const ability = new KadiAbility({
+  name: 'echo-ability',
+  version: '1.0.0',
+  description: 'Echo service with metadata',
+  scope: process.env.KADI_AGENT_SCOPE || 'global'
+});
+
+// Method 1: Simple handler
+ability.method('echo', async ({ message }) => ({
+  echo: message,
+  timestamp: new Date().toISOString()
+}));
+
+// Method 2: Handler with inline schema
+ability.method(
+  'format',
+  async ({ text, style }) => ({
+    formatted: style === 'upper' ? text.toUpperCase() : text.toLowerCase()
+  }),
+  {
+    description: 'Format text with specified style',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string', description: 'Text to format' },
+        style: {
+          type: 'string',
+          enum: ['upper', 'lower'],
+          description: 'Formatting style'
+        }
+      },
+      required: ['text', 'style']
+    },
+    outputSchema: {
+      type: 'object',
+      properties: {
+        formatted: { type: 'string', description: 'Formatted text' }
+      }
+    }
+  }
+);
 
-- **`KADI_BROKERS`**: Object containing all configured brokers with their parsed URLs.
-- **`KADI_BROKER_URL`**: Default broker URL (first one defined, for backward compatibility).
-- **`getBrokerUrl(brokerName)`**: Get URL for a specific broker by name. Returns `null` if not found.
-- **`getBrokerNames()`**: Get array of all available broker names.
-- **`setActiveBroker(brokerName)`**: Set the active broker for the session. Returns `true` if successful.
-- **`getActiveBrokerName()`**: Get the name of the currently active broker.
-- **`getActiveBrokerUrl()`**: Get the URL of the currently active broker.
-- **`getDefaultBrokerName()`**: Get the name of the default broker (first one defined).
-- **`selectBrokerFromEnv()`**: Set active broker from `KADI_BROKER` environment variable.
+// Start serving
+ability.serve().catch(console.error);
+```
 
-### Process Management Functions
+### Event Publishing and Subscription
 
-- **`runExecCommand(name, version, command)`**: Executes a command for initializing abilities.
-- **`runSpawnCommand(name, version, command)`**: Uses `spawn` to execute commands for subprocesses.
+**Note**: Events currently work for `native` and `stdio` protocols. Broker protocol event support is planned for future releases.
 
-## Usage Examples
+Abilities can publish events that agents can subscribe to:
 
 ```javascript
-import {
-  getProjectJSON,
-  runExecCommand,
-  IPCManager,
-  Broker
-} from '@kadi.build/core';
+// In your ability (service.js)
+const ability = new KadiAbility({ name: 'my-ability' });
+
+// Publish events from method handlers
+ability.method('echo', async ({ message }) => {
+  // Publish an event before returning the result
+  ability.publishEvent('echo:test-event', { from: 'message echo' });
+  ability.publishEvent('echo:test-event', { from: 'message echo 2' });
+
+  return { echo: message, timestamp: new Date().toISOString() };
+});
+
+// In your agent (index.js)
+const ability = await loadAbility('my-ability');
+
+// Subscribe to events BEFORE calling methods that emit them
+ability.events.on('echo:test-event', (data) => {
+  console.log(`[NATIVE] echo:test-event received:`, data);
+});
+
+// Now call the method that emits events
+const result = await ability.echo({ message: 'Hello world' });
+```
+
+**Important**: Always subscribe to events before calling methods that emit them, as events are emitted immediately when `publishEvent()` is called.
+
+### Ability Configuration (agent.json)
+
+Every ability should have an `agent.json` file that defines its capabilities and interfaces:
 
-async function setupProject() {
-  const projectConfig = getProjectJSON();
-  console.log(projectConfig);
-
-  await runExecCommand('example', '1.0', 'npm install');
-
-  // Broker management examples
-  console.log('Available brokers:', getBrokerNames());
-  console.log('All brokers:', KADI_BROKERS);
-
-  // Set active broker
-  setActiveBroker('remote');
-  console.log('Active broker:', getActiveBrokerUrl());
-
-  // IPC setup
-  const ipc = new IPCManager();
-  ipc.createInstance('python', 'pythonScript.py', 'pythonInstance');
-
-  // Traditional broker setup
-  Broker.addBroker('ws://example.com', 'exampleBroker');
-  let broker = Broker.getBroker('default');
-  console.log(`Connected to ${broker.url}`);
-  broker.send(
-    BrokerMessageBuilder.setup(
-      'TestAgent',
-      'A Broker Testing Agent',
-      null,
-      null
-    )
-  );
+```json
+{
+  "name": "echo-ability",
+  "kind": "ability",
+  "version": "1.0.0",
+  "license": "MIT",
+  "description": "Echo service with multiple transport support",
+  "scripts": {
+    "setup": "npm install",
+    "start": "node service.js"
+  },
+  "interfaces": {
+    "native": {
+      "entry": "service.js"
+    },
+    "stdio": {
+      "discover": true,
+      "timeoutMs": 10000
+    },
+    "broker": {
+      "discover": true,
+      "timeoutMs": 15000,
+      "serviceName": "echo-service"
+    }
+  },
+  "exports": [
+    {
+      "name": "echo",
+      "description": "Echo the input message",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "message": { "type": "string" }
+        },
+        "required": ["message"]
+      },
+      "outputSchema": {
+        "type": "object",
+        "properties": {
+          "echo": { "type": "string" },
+          "timestamp": { "type": "string" }
+        }
+      }
+    }
+  ],
+  "brokers": {
+    "local": "ws://localhost:8080",
+    "remote": "ws://api.example.com:8080"
+  }
 }
 ```
 
-### Broker Functions
+### Schema Definition Options
 
-- **`Broker`**: Manages interactions with broker systems.
-- **`IBroker`**: Broker instance interface with methods to manage its lifecycle and communications.
-- **`BrokerMessageBuilder`**: Assists in constructing messages for broker communication.
+The ability system provides two ways to define method schemas:
 
-## Broker Functions
+1. **Export Schemas** (defined in `agent.json` exports section)
+2. **Inline Schemas** (passed directly to `.method()`)
 
-The Broker system facilitates interaction between different agents and services within the Kadi environment.
+```javascript
+// Option 1: Define in agent.json exports section
+// The schema is picked up automatically if the method name matches
+// agent.json:
+{
+  "exports": [
+    {
+      "name": "process",
+      "description": "Process data",
+      "inputSchema": { /* ... */ },
+      "outputSchema": { /* ... */ }
+    }
+  ]
+}
 
-### `Broker` Interface
+// Option 2: Define inline when registering the method
+ability.method('process', handler, {
+  description: 'Process data',
+  inputSchema: { /* ... */ },
+  outputSchema: { /* ... */ }
+});
 
-- **`addBroker(url, name = 'default')`**: Adds a new broker connection. If a broker with the same name exists, it will be reused.
-- **`disconnect(name = 'default')`**: Disconnects the broker specified by the name.
-- **`deleteBroker(name = 'default')`**: Deletes the broker specified by the name and closes its connection.
-- **`send(message, brokerName = 'default')`**: Sends a message through the broker specified by the name.
-- **`addEventListener(event, listener, brokerName = 'default')`**: Adds an event listener to the specified broker.
-- **`removeEventListener(event, listener, brokerName = 'default')`**: Removes an event listener from the specified broker.
-- **`removeAllListeners(brokerName = 'default')`**: Removes all event listeners from the specified broker.
-- **`getBroker(brokerName = 'default')`**: Retrieves a broker instance by name.
+// Note: If both are defined, inline schemas take precedence over exports
+```
 
-### `IBroker` Instance
+**Important**: Specifying MCP schemas for ability handlers is particularly important for `broker` communication. If you only need `native` and `stdio` protocols, schemas can be omitted.
+
+## 🔄 Architecture Deep Dive
+
+### Ability Loading Sequence
+
+The loading process adapts based on the selected protocol:
+
+```mermaid
+sequenceDiagram
+    participant Client
+    participant loadAbility
+    participant FileSystem
+    participant ChildProcess
+    participant Ability
+    participant Broker
+
+    Client->>loadAbility: loadAbility('echo-js', protocol?)
+    loadAbility->>FileSystem: Read project/ability agent.json
+    FileSystem-->>loadAbility: Return ability version & config
+    loadAbility->>FileSystem: Check ability directory exists
+    loadAbility->>FileSystem: Read ability's agent.json manifest
+
+    alt protocol === 'native'
+        loadAbility->>FileSystem: Read entry point from manifest
+        loadAbility->>Ability: import(modulePath)
+        Ability-->>loadAbility: Return module exports
+        loadAbility->>loadAbility: Extract functions from module
+        loadAbility->>loadAbility: Build proxy with direct function calls
+    else protocol === 'stdio'
+        loadAbility->>ChildProcess: spawn(startCmd, { env: { KADI_PROTOCOL: 'stdio' }})
+        ChildProcess->>Ability: Start ability process
+        Ability->>Ability: Create StdioRpcServer
+        loadAbility->>Ability: Send __kadi_init via LSP frames
+        Ability-->>loadAbility: Return { name, version, functions }
+
+        opt if discover enabled
+            loadAbility->>Ability: Send __kadi_discover
+            Ability-->>loadAbility: Return { functions: {...} }
+        end
+
+        loadAbility->>loadAbility: Merge static exports + discovered functions
+        loadAbility->>loadAbility: Build proxy with RPC calls
+    else protocol === 'broker'
+        loadAbility->>loadAbility: Generate scope UUID
+        loadAbility->>ChildProcess: spawn(startCmd, { env: { KADI_PROTOCOL, KADI_BROKER_URL, KADI_AGENT_SCOPE, KADI_SERVICE_NAME }})
+        ChildProcess->>Ability: Start ability process
+
+        Note over Ability,Broker: Ability connects to broker
+        Ability->>Broker: WebSocket connect
+        Ability->>Broker: hello({ role: 'agent' })
+        Broker-->>Ability: { nonce }
+        Ability->>Broker: authenticate({ publicKey, signature })
+        Broker-->>Ability: { agentId }
+        Ability->>Broker: registerCapabilities({ tools, scopes: [KADI_AGENT_SCOPE] })
+
+        Note over loadAbility,Broker: Parent connects to broker
+        loadAbility->>Broker: WebSocket connect
+        loadAbility->>Broker: hello/auth/register sequence
+
+        opt if discover enabled
+            loadAbility->>Broker: listTools({ scopes: [scope] })
+            Broker-->>loadAbility: Return available tools
+        end
+
+        loadAbility->>loadAbility: Merge static exports + broker tools
+        loadAbility->>loadAbility: Build proxy with broker RPC
+    end
+
+    loadAbility->>Client: Return ability proxy
+    Client->>Client: ability.method({ params })
+```
 
-This class extends `EventEmitter` and manages individual broker connections:
+### Method Registration & Serving
+
+How abilities register methods and start serving:
+
+```mermaid
+sequenceDiagram
+    participant Dev as Developer
+    participant KA as KadiAbility
+    participant Server as RpcServer
+    participant Transport
+    participant Client
+
+    Note over Dev,KA: Registration Phase
+    Dev->>KA: new KadiAbility({ name, scope: process.env.KADI_AGENT_SCOPE })
+    Dev->>KA: ability.method('echo', handler)
+    KA->>KA: Store in methodHandlers Map
+
+    Dev->>KA: ability.method('transform', handler, schema)
+    KA->>KA: Store handler in methodHandlers
+    KA->>KA: Store schema in methodMCPSchemas
+
+    Note over KA,Transport: Serving Phase
+    Dev->>KA: ability.serve()
+    KA->>KA: Detect protocol from env/options
+
+    alt protocol === 'stdio'
+        KA->>Server: new StdioRpcServer()
+        Server->>Transport: new StdioFrameReader(stdin)
+        Server->>Transport: new StdioFrameWriter(stdout)
+        Transport->>Transport: Listen for LSP frames on stdin
+    else protocol === 'broker'
+        KA->>Server: new BrokerRpcServer()
+        Server->>Transport: WebSocket connect to broker
+        Server->>Transport: Handshake (hello/auth)
+        Server->>KA: ability.extractToolsForBroker()
+        KA-->>Server: Return tools from exports + inline schemas
+        Server->>Transport: registerCapabilities({ tools, scopes })
+    end
+
+    Server->>KA: Forward events (start, request, response, error)
+
+    Note over Transport,Client: Request Handling
+    Client->>Transport: Incoming request
+    Transport->>Server: Parse & validate request
+    Server->>KA: getMethodHandler(method)
+    KA-->>Server: Return handler function
+    Server->>Server: Execute handler with timeout
+    Server->>Transport: Send response
+    Transport->>Client: Return result
+```
 
-- **`constructor(url, name)`**: Initializes a new broker connection.
-- **`send(message)`**: Sends a message through the WebSocket connection.
-- **`getConnectedAgents()`**: Retrieves a list of currently connected agents.
+### Broker Protocol Communication Flow
+
+Detailed view of broker-based communication:
+
+```mermaid
+sequenceDiagram
+    participant Agent as Agent (Parent)
+    participant Ability as Ability (Child)
+    participant Broker as KADI Broker
+    participant Consumer as Other Agent/Client
+
+    Note over Agent,Ability: Initialization
+    Agent->>Agent: Generate scope UUID
+    Agent->>Ability: spawn(env: { KADI_AGENT_SCOPE: uuid })
+
+    Note over Ability,Broker: Ability Registration
+    Ability->>Broker: Connect WebSocket
+    Ability->>Broker: hello({ role: 'agent' })
+    Broker-->>Ability: { nonce: 'abc123' }
+    Ability->>Ability: Generate ephemeral Ed25519 keypair
+    Ability->>Broker: authenticate({ publicKey, signature(nonce) })
+    Broker-->>Ability: { agentId: 'ability-123' }
+    Ability->>Broker: registerCapabilities({ tools: [...], scopes: [uuid] })
+    Broker->>Broker: Store capabilities in scope
+
+    Note over Agent,Broker: Agent Connection
+    Agent->>Broker: Connect WebSocket
+    Agent->>Broker: hello/authenticate sequence
+    Broker-->>Agent: { agentId: 'agent-456' }
+
+    Note over Agent,Broker: Method Call via Broker
+    Agent->>Broker: callAbility({ toolName: 'echo', args: { message: 'test' }, requestId })
+    Broker-->>Agent: { requestId }
+    Broker->>Ability: agent.message({ toolName, args, requestId, from: 'agent-456' })
+    Ability->>Ability: Execute handler
+    Ability->>Broker: ability.result({ requestId, toSessionId: 'agent-456', result })
+    Broker->>Agent: ability.result({ requestId, result })
+
+    Note over Broker,Consumer: Scope Isolation
+    Consumer->>Broker: listTools({ scopes: ['global'] })
+    Broker-->>Consumer: { tools: [] } // Ability not visible (wrong scope)
+    Consumer->>Broker: listTools({ scopes: [uuid] })
+    Broker-->>Consumer: { tools: ['echo', 'transform'] } // Now visible
+```
 
-### `BrokerMessageBuilder`
+### Stdio Protocol Frame Processing
+
+How LSP-style frames are processed:
+
+```mermaid
+sequenceDiagram
+    participant Parent as Parent Process
+    participant SR as StdioFrameReader
+    participant SW as StdioFrameWriter
+    participant Server as StdioRpcServer
+    participant Ability as KadiAbility
+
+    Note over Parent,SR: Incoming Request
+    Parent->>SR: Write to stdin: "Kadi-Content-Length: 52\r\n\r\n{...}"
+    SR->>SR: Buffer incoming data
+    SR->>SR: Look for Content-Length header
+    SR->>SR: Parse header, extract body length
+    SR->>SR: Wait for complete body
+    SR->>SR: Parse JSON from body
+    SR->>Server: onMessage({ success: true, data: request })
+
+    Server->>Server: Validate JSON-RPC format
+    Server->>Ability: getMethodHandler(request.method)
+    Ability-->>Server: Return handler
+    Server->>Server: Execute handler(params) with timeout
+
+    Note over Server,Parent: Response
+    Server->>SW: write(response)
+    SW->>SW: JSON.stringify(response)
+    SW->>SW: Calculate byte length
+    SW->>SW: Create header: "Kadi-Content-Length: N\r\n\r\n"
+    SW->>Parent: Write header + body to stdout
+
+    Note over SR: Error Recovery
+    alt Frame Corruption
+        SR->>SR: Detect invalid frame
+        SR->>SR: Search for next Content-Length marker
+        SR->>SR: Skip corrupted bytes
+        SR->>Server: onMessage({ success: false, error: 'FRAME_CORRUPTION' })
+        Server->>Server: Log error, continue processing
+    end
+```
 
-Utility class for constructing broker messages:
+## 📥 Loading Abilities
 
-- **`create_message(type, data)`**: Creates a JSON string with the specified type and data.
-- **`message(to, content)`**: Constructs a message directed to a specific peer.
-- **`setup(name, description, limit, uuid)`**: Creates a setup message for registering the broker.
-- **`suspend()`**: Constructs a suspend message.
-- **`finish()`**: Constructs a finish message.
-- **`list()`**: Constructs a list message to request a list of connected agents.
+### Basic Loading
 
-### IPC Functions
+```javascript
+import { loadAbility } from '@kadi.build/core';
 
-- **`IPCMessageBuilder`**: Constructs messages for IPC interactions.
-- **`IPCManager`**: Manages setup and lifecycle of IPC connections.
-- **`IAbilityIPC`**: Represents an IPC ability instance with methods to manage its lifecycle and communications.
+// Auto-detect protocol from agent.json
+const ability = await loadAbility('my-ability');
 
-### `IPCManager`
+// Explicitly specify protocol
+const stdioAbility = await loadAbility('my-ability', 'stdio');
+const brokerAbility = await loadAbility('my-ability', 'broker');
+const nativeAbility = await loadAbility('my-ability', 'native');
+```
 
-Manages the lifecycle and setup of interprocess communications.
+### Working with Loaded Abilities
 
-- **`createInstance(language, commandString, name = 'default')`**: Creates and manages a new IPC instance for the specified language.
-- **`getInstance(name)`**: Retrieves an existing IPC instance by name.
-- **`shutdownInstance(name)`**: Shuts down an existing IPC instance by name.
+```javascript
+// List available methods
+const methods = ability.__list();
+console.log('Available methods:', methods);
 
-### `IAbilityIPC` Instance
+// Call methods
+const result = await ability.someMethod({ param: 'value' });
 
-Manages an individual interprocess communication instance:
+// Direct RPC call (bypasses method validation)
+const response = await ability.call('someMethod', { param: 'value' });
 
-- **`start()`**: Starts the child process associated with this IPC instance.
-- **`launch()`**: Sends the launch command to the associated process.
-- **`sendMessage(message)`**: Sends a JSON-formatted message to the child process.
-- **`shutdown()`**: Sends a shutdown command to the child process and terminates it.
+// Subscribe to events
+ability.events.on('custom:event', (data) => {
+  console.log('Event received:', data);
+});
 
-### `IPCMessageBuilder`
+// Note: Events work for native and stdio protocols
+// Subscribe before calling methods that emit events
+```
 
-Utility class for constructing IPC messages:
+### Loading Context
 
-- **`createMessage(type, contents)`**: Creates a JSON string with the specified type and contents.
-- **`launch(commandString)`**: Constructs a launch message with the specified command string.
-- **`shutdown()`**: Constructs a shutdown message.
-- **`message(content)`**: Constructs a general message with the specified content.
+The loader automatically resolves ability versions from:
 
-## Usage Examples
+1. **Project context**: Reads from project's `agent.json`
+2. **Nested context**: When loading from within another ability
+3. **Explicit version**: Can be specified in ability name
 
-Here's how you might use the IPC and Broker functionalities:
+## ⚙️ Configuration
 
-### Interacting with IPC
+### Environment Variables
+
+```bash
+# Set default protocol
+export KADI_PROTOCOL=stdio
+
+# Configure broker
+export KADI_BROKER_URL=ws://localhost:8080
+export KADI_SERVICE_NAME=my-service
+export KADI_AGENT_SCOPE=project-123
+```
+
+### Environment Variables for Child Processes
+
+When abilities are spawned as child processes (stdio and broker protocols), the parent process passes down important environment variables:
 
 ```javascript
-console.log('Starting IPC Ability Interface test...');
+// In your ability code, you can access these variables:
+const protocol = process.env.KADI_PROTOCOL; // 'stdio' or 'broker'
+const brokerUrl = process.env.KADI_BROKER_URL; // For broker protocol
+const serviceName = process.env.KADI_SERVICE_NAME; // For broker protocol
+const agentScope = process.env.KADI_AGENT_SCOPE; // For broker protocol
+
+// Use them to configure your ability behavior
+const ability = new KadiAbility({
+  name: 'my-ability',
+  scope: process.env.KADI_AGENT_SCOPE || 'global'
+  // Ability automatically uses KADI_PROTOCOL to determine transport
+});
+```
 
-// Create Python IPC instance
-const pythonIPC = IPCManager.createInstance(
-  'python',
-  'echo "Hello, World!"',
-  'pythonTest'
-);
+### Project Structure
 
-pythonIPC.on('error', (error) => {
-  console.error('Handled Python Error:', error);
-  // Consider appropriate error handling or recovery actions here
+```
+my-project/
+├── agent.json              # Project configuration
+├── abilities/              # Installed abilities
+│   └── echo-ability/
+│       └── 1.0.0/
+│           ├── agent.json  # Ability configuration
+│           ├── service.js  # Ability implementation
+│           └── package.json
+├── modules/                # Source modules
+│   └── echo-ability/       # Development version
+└── index.js               # Main entry point
+```
+
+## 🚀 Advanced Usage
+
+### Event System
+
+KADI abilities support two types of events:
+
+#### 1. Lifecycle Events (All Protocols)
+
+These are internal ability lifecycle events that work across all protocols:
+
+```javascript
+const ability = new KadiAbility({ name: 'events-ability' });
+
+// Listen to lifecycle events
+ability.on('start', ({ protocol, methods }) => {
+  console.log(`Started with ${protocol}, methods: ${methods.join(', ')}`);
 });
 
-pythonIPC.on('critical-error', (error) => {
-  console.error('Critical Error from Python:', error);
-  // Handle critical errors, potentially restarting the process or alerting administrators
+ability.on('request', ({ id, method, params }) => {
+  console.log(`Request ${id}: ${method}`);
 });
 
-pythonIPC.on('message', (msg) => {
-  console.log('Message from Python:', msg);
+ability.on('response', ({ id, result, error }) => {
+  if (error) console.error(`Error in ${id}:`, error);
+  else console.log(`Response ${id}:`, result);
 });
 
-pythonIPC.on('broker', (msg) => {
-  console.log('Broker message from Python:', msg);
+ability.on('error', (error) => {
+  console.error('Ability error:', error);
 });
+```
 
-pythonIPC.on('shutdown', () => {
-  console.log('Python IPC has shut down.');
+#### 2. Custom Events (Native and Stdio Protocols Only - for now)
+
+Abilities can publish custom events that agents can subscribe to:
+
+```javascript
+// In your ability
+const ability = new KadiAbility({ name: 'my-ability' });
+
+ability.method('process', async ({ data }) => {
+  // Publish events during processing
+  ability.publishEvent('process:started', {
+    timestamp: new Date().toISOString()
+  });
+
+  // ... do work ...
+
+  ability.publishEvent('process:completed', {
+    result: 'success',
+    timestamp: new Date().toISOString()
+  });
+
+  return { processed: data };
 });
 
-Broker.addBroker('http://your.broker.com', 'default');
-let brk = Broker.getBroker('default');
-broker = brk;
-
-pythonIPC.attachBroker(brk);
-
-brk.on('open', function open() {
-  console.log(`Connected to ${brk.url}`);
-  const jsonObject = BrokerMessageBuilder.setup(
-    'TestAgent',
-    'A Broker Testing Agent',
-    null,
-    null
-  );
-  brk.send(jsonObject);
+// In your agent (index.js)
+const ability = await loadAbility('my-ability');
+
+// Subscribe to custom events BEFORE calling methods
+ability.events.on('process:started', (data) => {
+  console.log(`Process started at: ${data.timestamp}`);
 });
 
-brk.on('message', function incoming(data) {
-  let msg = JSON.parse(data);
-  if (msg.type == 'setup') {
-    (async () => {
-      try {
-        await GetLLMProxy();
-      } catch (error) {
-        console.error('Error during GetLLMProxy:', error.message);
-      }
-    })();
+ability.events.on('process:completed', (data) => {
+  console.log(`Process completed: ${data.result} at ${data.timestamp}`);
+});
+
+// Now call the method that emits events
+await ability.process({ data: 'test' });
+```
+
+**Important Notes:**
+
+- Custom events only work with `native` and `stdio` protocols for now
+- Always subscribe to events before calling methods that emit them
+- Events are emitted immediately when `publishEvent()` is called
+- Broker protocol event support is in progress
+
+### Error Handling
+
+```javascript
+try {
+  const ability = await loadAbility('my-ability', 'stdio');
+  const result = await ability.riskyMethod({ data: 'test' });
+} catch (error) {
+  if (error.message.includes('not found')) {
+    console.error('Ability not installed. Run: kadi install');
+  } else if (error.message.includes('timeout')) {
+    console.error('Method timed out. Check ability health.');
+  } else if (error.message.includes('not exposed by this ability')) {
+    console.error(
+      'Method not available. Use ability.__list() to see available methods.'
+    );
+  } else {
+    console.error('Unexpected error:', error);
   }
-  // console.log('Received:', formatJSON(data));
+}
+```
+
+## 🔧 Development Workflow
+
+### Testing Local Changes
+
+When developing new features or testing changes to `@kadi.build/core` before publishing to NPM:
+
+0. **clone the repository**
+
+```bash
+git clone https://gitlab.com/humin-game-lab/kadi/kadi-core.git
+```
+
+1. **Pack the local version** (in the kadi-core directory):
+
+```bash
+cd /path/to/kadi-core
+npm pack
+# This creates: kadi.build-core-X.Y.Z.tgz
+```
+
+1. **Install in your project**:
+
+```bash
+cd /path/to/your-project
+npm install /path/to/kadi-core/kadi.build-core-X.Y.Z.tgz
+```
+
+1. **For ability development**, update the ability's preflight script:
+
+```json
+{
+  "scripts": {
+    "preflight": "npm uninstall @kadi.build/core && npm install /path/to/kadi.build-core-X.Y.Z.tgz"
+  }
+}
+```
+
+## 📖 API Reference
+
+### Core Classes
+
+#### `KadiAbility`
+
+The main class for creating abilities.
+
+```javascript
+import { KadiAbility } from '@kadi.build/core';
+
+const ability = new KadiAbility({
+  name: 'my-ability',
+  version: '1.0.0',
+  description: 'My ability description',
+  scope: 'global', // or process.env.KADI_AGENT_SCOPE
+  protocol: 'stdio' // 'native', 'stdio', or 'broker'
 });
+```
+
+**Methods:**
+
+- `ability.method(name, handler, schema?)` - Register a method
+- `ability.serve()` - Start serving requests
+- `ability.publishEvent(eventName, data)` - Publish an event
+- `ability.on(event, handler)` - Listen to lifecycle events
+
+#### `loadAbility`
+
+Load an ability by name and protocol.
+
+```javascript
+import { loadAbility } from '@kadi.build/core';
+
+const ability = await loadAbility('ability-name', 'protocol');
+```
+
+**Returns:** A proxy object with:
+
+- Direct method calls (e.g., `ability.echo({ message: 'hello' })`)
+- `ability.__list()` - List available methods
+- `ability.events` - EventEmitter for subscribing to events (native/stdio protocols only)
+- `ability.call(method, params)` - Direct RPC call
+
+### Utility Functions
+
+```javascript
+import {
+  createLogger,
+  getProjectJSON,
+  getAbilityJSON,
+  getBrokerUrl,
+  runExecCommand
+} from '@kadi.build/core';
+```
+
+## 🎮 Running the Examples
+
+### Quick Start with Example Agent
+
+The `@kadi.build/core` package includes a complete example demonstrating multi-language abilities (JavaScript and Go) with all three transport protocols.
+
+The `examples` folder contains:
+
+```
+examples/
+├── example-abilities/       # Sample abilities in different languages
+│   ├── echo-js/            # JavaScript ability using KadiAbility
+│   │   ├── agent.json      # Ability configuration
+│   │   ├── service.js      # Implementation
+│   │   └── package.json
+│   └── hash-go/            # Go ability demonstrating polyglot support
+│       ├── agent.json
+│       ├── go.mod
+│       └── cmd/hash_ability/main.go
+└── example-agent/          # Sample agent using the abilities
+    ├── agent.json          # Declares dependencies on abilities
+    ├── index.js            # Demonstrates all loading patterns
+    └── package.json
+```
+
+#### Step 0: Have the KADI broker running locally
+
+```bash
+kadi broker up
+```
+
+#### Step 1: Navigate to the example agent
 
-brk.on('error', function error(error) {
-  console.error('WebSocket error:', error);
+```bash
+cd /path/to/kadi-core/examples/example-agent
+```
+
+#### Step 2: Install abilities
+
+```bash
+# Inside 'example-agent' folder
+kadi install
+```
+
+This installs the `echo-js` (JavaScript) and `hash-go` (Go) abilities defined in the agent.json.
+
+#### Step 3: Run the agent
+
+```bash
+kadi run
+```
+
+#### Expected Output
+
+You should see the agent testing various abilities and protocols:
+
+```
+=== WORKING ABILITIES ===
+
+🔧 Loading echo-js ability using native (Javascript)...
+Available methods: [ 'echo', 'say_message' ]
+Echo-js echo result: {
+  echo: 'I am calling echo-js echo method from Javascript',
+  timestamp: '2025-08-15T00:20:23.276Z',
+  length: 48
+}
+
+🔧 Loading echo-js ability using stdio (Javascript)...
+Available methods: [ 'echo', 'say_message' ]
+Echo-js echo result: {
+  echo: 'I am calling echo-js echo method from Javascript',
+  timestamp: '2025-08-15T00:20:23.339Z',
+  length: 48
+}
+```
+
+#### Step 4: Stop and Clean Up
+
+```bash
+# Stop the agent
+Ctrl + C
+
+# Clean up installed abilities and node_modules
+kadi run clean
+```
+
+### What the Example Demonstrates
+
+1. **Polyglot Abilities**: Go (`hash-go`) and JavaScript (`echo-js`) abilities working together
+2. **Protocol Flexibility**: Same ability (`echo-js`) loaded via native, stdio, and broker
+3. **Error Handling**: Graceful handling when calling non-existent methods
+4. **Method Discovery**: Using `__list()` to discover available methods
+5. **Schema Support**: Both inline and export-based schema definitions
+6. **Event System**: Publishing and subscribing to events across protocols
+7. **Event Timing**: Demonstrates the importance of subscribing to events before calling methods
+
+### Exploring the Code
+
+**echo-js ability** (`examples/example-abilities/echo-js/service.js`):
+
+- Shows method registration with and without schemas
+- Demonstrates scope configuration for broker visibility
+- Uses environment variables for protocol adaptation
+- Includes event publishing examples using `publishEvent()`
+- Demonstrates how to emit events from method handlers
+
+**hash-go ability** (`examples/example-abilities/hash-go/`):
+
+- Demonstrates Go SDK integration
+- Shows stdio protocol with a compiled language
+- Implements SHA256 hashing as a service
+
+**example-agent** (`examples/example-agent/index.js`):
+
+- Shows all three loading patterns
+- Demonstrates error handling
+- Tests cross-language ability communication
+- Includes event subscription examples using `ability.events.on()`
+- Shows how to subscribe to events before calling methods
+- Demonstrates event handling across different protocols (native/stdio)
+
+## 💡 Additional Examples
+
+### Complete Echo Service Example
+
+**service.js**:
+
+```javascript
+#!/usr/bin/env node
+import { KadiAbility } from '@kadi.build/core';
+
+const echoAbility = new KadiAbility({
+  name: 'echo-service',
+  version: '1.0.0',
+  description: 'Multi-protocol echo service',
+  scope: process.env.KADI_AGENT_SCOPE // Important for broker visibility
 });
 
-brk.on('close', function close() {
-  console.log('Disconnected from the server');
-  process.exit(0); // Exit the process when the WebSocket connection is closed
+// Simple echo with metadata
+echoAbility.method('echo', async ({ message }) => {
+  // Publish events (works for native and stdio protocols)
+  echoAbility.publishEvent('echo:test-event', { from: 'message echo' });
+  echoAbility.publishEvent('echo:test-event', { from: 'message echo 2' });
+
+  return {
+    echo: message,
+    timestamp: new Date().toISOString(),
+    length: message?.length || 0
+  };
 });
 
-// Send launch command
+// Transform text
+echoAbility.method(
+  'transform',
+  async ({ text, operations }) => {
+    let result = text;
+    for (const op of operations) {
+      switch (op) {
+        case 'upper':
+          result = result.toUpperCase();
+          break;
+        case 'lower':
+          result = result.toLowerCase();
+          break;
+        case 'reverse':
+          result = result.split('').reverse().join('');
+          break;
+      }
+    }
+    return { transformed: result };
+  },
+  {
+    description: 'Transform text with multiple operations',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: { type: 'string' },
+        operations: {
+          type: 'array',
+          items: { enum: ['upper', 'lower', 'reverse'] }
+        }
+      },
+      required: ['text', 'operations']
+    }
+  }
+);
+
+echoAbility.serve().catch(console.error);
+```
+
+**Using the service**:
+
+```javascript
+import { loadAbility } from '@kadi.build/core';
+
+async function demo() {
+  // Try all protocols
+  for (const protocol of ['native', 'stdio', 'broker']) {
+    console.log(`\nTesting ${protocol} protocol:`);
+
+    try {
+      const echo = await loadAbility('echo-service', protocol);
+
+      // Subscribe to events (works for native and stdio protocols)
+      echo.events.on('echo:test-event', (data) => {
+        console.log(`Echo event received: ${data.from}`);
+      });
+
+      // Simple echo
+      const result1 = await echo.echo({
+        message: `Hello from ${protocol}!`
+      });
+      console.log('Echo:', result1);
+
+      // Transform
+      const result2 = await echo.transform({
+        text: 'Hello World',
+        operations: ['lower', 'reverse']
+      });
+      console.log('Transform:', result2);
+    } catch (error) {
+      console.error(`${protocol} failed:`, error.message);
+    }
+  }
+}
+
+demo();
+```
+
+## 🎯 Real-World Event Example
+
+Here's the exact event pattern used in the example code:
+
+**In your ability (service.js):**
+
+```javascript
+const echoAbility = new KadiAbility({
+  name: 'echo-js',
+  version: '0.0.1',
+  scope: process.env.KADI_AGENT_SCOPE
+});
+
+async function echo(message) {
+  const timestamp = new Date().toISOString();
+  const messageText = message?.message ?? message ?? '';
+  const length = messageText.length;
 
-//Utilize log files
-// pythonIPC.sendMessage(IPCMessageBuilder.launch(pythonIPC.commandString, process.cwd() + "/logs"));
+  // Publish events (works for native and stdio protocols)
+  echoAbility.publishEvent('echo:test-event', { from: 'message echo' });
+  echoAbility.publishEvent('echo:test-event', { from: 'message echo 2' });
 
-//No log files created
-pythonIPC.sendMessage(IPCMessageBuilder.launch(pythonIPC.commandString));
+  return { echo: messageText, timestamp, length };
+}
+
+echoAbility.method('echo', echo);
 ```
 
-### Handling IPC
+**In your agent (index.js):**
 
 ```javascript
-const ipcManager = new IPCManager();
-const ipcInstance = ipcManager.createInstance('node', 'app.js', 'nodeApp');
-ipcInstance.on('message', (message) => console.log(message));
+// Subscribe first
+echoJsAbility.events.on('echo:test-event', (data) => {
+  console.log(`[NATIVE] echo:test-event received:`, data);
+});
+
+// Now trigger the method that emits the event
+const echoJsResult = await echoJsAbility.echo({
+  message: 'I am calling echo-js echo method from Javascript'
+});
+```
+
+**Key Points:**
+
+- Events work for `native` and `stdio` protocols only
+- Always subscribe to events BEFORE calling methods that emit them
+- Events are emitted immediately when `publishEvent()` is called
+- Use `ability.events.on()` to subscribe to custom events
+- Use `ability.on()` to listen to lifecycle events
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+**Ability Not Found**
+
+```
+Error: Ability 'my-ability' version '1.0.0' is not installed
+```
+
+**Solution**: Run `kadi install` to install project dependencies
+
+**Broker Connection Failed**
+
+```
+Error: Failed to connect to KADI Broker at ws://localhost:8080
+```
+
+**Solution**: Ensure the broker is running: `kadi broker start`
+
+**Method Not Found**
+
+```
+Error: Method 'someMethod' is not exposed by this ability
+```
+
+**Solution**: Check ability exports or use `__list()` to see available methods
+
+**Protocol Not Supported**
+
+```
+Error: Unsupported ability interface protocol: custom
+```
+
+**Solution**: Ability must define the protocol in its `agent.json` interfaces
+
+**Event Subscription Issues**
+
+```
+TypeError: Cannot read property 'on' of undefined
+```
+
+**Solution**: Make sure you're accessing `ability.events.on()` not `ability.on()` for custom events
+
+**Event Protocol Support**
+
+```
+Events are only supported for 'native' and 'stdio' protocols
 ```
 
+**Solution**: Events currently work for `native` and `stdio` protocols only. Broker protocol event support is planned for future releases.
+
+### Debug Mode
+
+Enable detailed logging:
+
+```bash
+DEBUG=kadi:* node index.js
+```
+
+Check ability logs:
+
+```bash
+tail -f abilities/my-ability/1.0.0/my-ability.log
+```
+
+## 🤝 Contributing
+
+We welcome contributions! Please see our [Contributing Guide](CONTRIBUTING.md) for details.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) file for details
+
+## 🔗 Related Projects
+
+- [@kadi.build/cli](https://gitlab.com/humin-game-lab/kadi/kadi) - Command-line interface
+- [@kadi.build/broker](https://gitlab.com/humin-game-lab/kadi/kadi-broker) - The KADI broker
+
+## 📚 Resources
+
+- [Official Documentation](https://docs.kadi.build)
+- [API Reference](https://docs.kadi.build/api)
+- [Tutorial: Building Your First Ability](https://docs.kadi.build/tutorial)
+- [Architecture Deep Dive](https://docs.kadi.build/architecture)
+
 ---
 
-## TODO:
-
-- Once @kadi.build/core and dependencies are done, @kadi.build/cli (and all commands), need to be rewritten, using the @kadi.build/core module. this will be v1.0 release
-
-* [ ] add getConnectedAgents to the Broker, it should call the IBroker method
-
-* [x] add key to IBroker object
-* [ ] IBroker on 'message' should listen for setup event, and update teh uuid and key for the IBroker object
-
-* [ ] Extract Broker and IPC to their own node module and host on npm
-* [x] Publish @kadi.build/core to npm
-* [x] Setup of python environment needs to happen once an IPC Inteface is created
-      This include setting up the virtual environment and installing the required packages
-* [x] Add method to IPCManger to set IPCInterfaces from agent.json. If IPCManger has empty list, it thorws an error that no IAbilityIPC's can be created. IPCManger passes the proper interface command to IAbilityIPC on creation from this list, IAbilityIPC does not need access directly to agent.json. Controlling app can update this list anytime a new IAbilityInterface is created, allowing the agent.json to be updated during runtime.
-* [x] Need to adapt ipc.js to read from the @kadi.build/core folder when trying to open IPC instances, instead of project folder. @kadi.build/core should be in the npm_modules folder (when deployed)
-* [x] The test code needs to fully test the IPCManger interface, and not just the IPCAbility
-* [x] If node fails, we need to make sure python IPC interface and child processes also close out.
-* [x] Add buffer to error handeling in IAbilityIPC, mimic same process used in std input
-* [x] Verify if Python IAbilityIPC needs to utilize buffering, and node passing '\n' at end of jso
-* [x] Setup passthrough for broker messages to/from Language IPC interface
-* [x] Add broker message builder/parser in python IAbilityIPC
-* [x] Update BrokerMessageBuilder to use same format at IPCMessageBuilder
-* [x] Update Broker so it extends EventEmitter, rather than have a property of event emitter (similar to IAbilityIPC)
-* [x] update python IAbility so that it creates a timestamped command_output.log file, new file for each run, in the project root directory... not the @kadi.build/core directory
-* [x] Comment out debug messages
-* [x] Add ability to allow for launched process to be piped to event handler (launch command should default to process, but allow user to set flag that will save all outputs to file in the event handler)
+Built with ❤️ by the KADI team