@telorun/kernel 0.2.4 → 0.2.5

package/src/event-stream.ts

@@ -0,0 +1,121 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+/**
+ * Streaming event log for debugging and testing
+ * Records all events in JSONL format (one JSON object per line)
+ * Useful for observing runtime execution, testing, and debugging
+ */
+export class EventStream {
+  private filePath: string;
+  private isEnabled: boolean = false;
+
+  constructor(filePath?: string) {
+    this.filePath = filePath || '';
+    this.isEnabled = !!filePath;
+  }
+
+  /**
+   * Enable event streaming to a file
+   */
+  async enable(filePath: string): Promise<void> {
+    this.filePath = filePath;
+    this.isEnabled = true;
+
+    // Ensure directory exists
+    const dir = path.dirname(filePath);
+    if (dir !== '.' && dir !== '') {
+      await fs.mkdir(dir, { recursive: true });
+    }
+
+    // Initialize file (truncate if exists)
+    await fs.writeFile(filePath, '', 'utf-8');
+  }
+
+  /**
+   * Log an event to the stream
+   */
+  async log(
+    event: string,
+    payload?: any,
+    metadata?: {
+      namespace?: string;
+      resource?: string;
+      kind?: string;
+      name?: string;
+    },
+  ): Promise<void> {
+    if (!this.isEnabled) {
+      return;
+    }
+
+    const logEntry = {
+      timestamp: new Date().toISOString(),
+      event,
+      payload,
+      ...metadata,
+    };
+
+    try {
+      const line = JSON.stringify(logEntry) + '\n';
+      await fs.appendFile(this.filePath, line, 'utf-8');
+    } catch (error) {
+      console.error('Failed to write event to stream:', error);
+    }
+  }
+
+  /**
+   * Read all events from the stream as an array
+   * Useful for testing
+   */
+  async readAll(): Promise<Array<Record<string, any>>> {
+    if (!this.isEnabled || !this.filePath) {
+      return [];
+    }
+
+    try {
+      const content = await fs.readFile(this.filePath, 'utf-8');
+      if (!content.trim()) {
+        return [];
+      }
+      return content
+        .trim()
+        .split('\n')
+        .map((line) => JSON.parse(line));
+    } catch (error) {
+      console.error('Failed to read event stream:', error);
+      return [];
+    }
+  }
+
+  /**
+   * Filter events by type
+   */
+  async getEventsByType(
+    eventType: string,
+  ): Promise<Array<Record<string, any>>> {
+    const all = await this.readAll();
+    return all.filter((e) => e.event === eventType);
+  }
+
+  /**
+   * Get the file path for the event stream
+   */
+  getFilePath(): string {
+    return this.filePath;
+  }
+
+  /**
+   * Check if event streaming is enabled
+   */
+  isEnabledStream(): boolean {
+    return this.isEnabled;
+  }
+
+  /**
+   * Disable event streaming
+   */
+  disable(): void {
+    this.isEnabled = false;
+  }
+}

package/src/events.ts

@@ -0,0 +1,99 @@
+import { RuntimeEvent } from "@telorun/sdk";
+
+type EventHandler = (payload?: any) => void | Promise<void>;
+
+export class EventBus {
+  private handlers: Map<string, Set<EventHandler>> = new Map();
+
+  private validateEventName(event: string): void {
+    if (
+      event === "" ||
+      !/^(\*|[A-Za-z_][A-Za-z0-9_]*)(\.(\*|[A-Za-z_][A-Za-z0-9_]*))*$/.test(event)
+    ) {
+      throw new Error(`Invalid event name "${event}". Expected format "Text.Text" with no spaces.`);
+    }
+  }
+
+  private matchesPattern(pattern: string, event: string): boolean {
+    if (pattern === "*") {
+      return true;
+    }
+    if (pattern === event) {
+      return true;
+    }
+    if (!pattern.includes("*")) {
+      return false;
+    }
+    const patternParts = pattern.split(".");
+    const eventParts = event.split(".");
+    if (patternParts.length !== eventParts.length) {
+      return false;
+    }
+    for (let i = 0; i < patternParts.length; i += 1) {
+      const part = patternParts[i];
+      if (part === "*") {
+        continue;
+      }
+      if (part !== eventParts[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  on(event: string, handler: EventHandler): void {
+    this.validateEventName(event);
+    const set = this.handlers.get(event) || new Set();
+    set.add(handler);
+    this.handlers.set(event, set);
+  }
+
+  once(event: string, handler: EventHandler): void {
+    this.validateEventName(event);
+    const wrapper: EventHandler = async (payload?: any) => {
+      this.off(event, wrapper);
+      await handler(payload);
+    };
+    this.on(event, wrapper);
+  }
+
+  off(event: string, handler: EventHandler): void {
+    this.validateEventName(event);
+    const set = this.handlers.get(event);
+    if (!set) {
+      return;
+    }
+    set.delete(handler);
+    if (set.size === 0) {
+      this.handlers.delete(event);
+    }
+  }
+
+  async emit(event: string, payload?: any, metadata?: any): Promise<void> {
+    const handlers: EventHandler[] = [];
+    for (const [pattern, set] of this.handlers.entries()) {
+      if (!this.matchesPattern(pattern, event)) {
+        continue;
+      }
+      for (const handler of set) {
+        handlers.push(handler);
+      }
+    }
+    if (handlers.length === 0) {
+      return;
+    }
+    const evt: RuntimeEvent = { name: event, payload, metadata };
+    for (const handler of handlers) {
+      await handler(evt);
+    }
+  }
+
+  hasHandlers(event: string): boolean {
+    for (const [pattern, set] of this.handlers.entries()) {
+      if (set.size > 0 && this.matchesPattern(pattern, event)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+export { ControllerRegistry } from "./controller-registry.js";
+export { EventStream } from "./event-stream.js";
+export { Kernel } from "./kernel.js";
+export { Loader } from "./loader.js";
+export { ManifestRegistry as Registry } from "./registry.js";
+export { ResourceURI } from "./resource-uri.js";
+