@donkeylabs/server 2.0.24 → 2.0.26

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@donkeylabs/server",
-  "version": "2.0.24",
+  "version": "2.0.26",
   "type": "module",
   "description": "Type-safe plugin system for building RPC-style APIs with Bun",
   "main": "./src/index.ts",

package/src/core/workflow-executor.ts

@@ -91,6 +91,27 @@ async function main(): Promise<void> {
       plugins: bootstrap.manager.getServices(),
       events: createIpcEventBridge(socket, instanceId),
       pollInterval: 1000,
+      emitCustomEvent: async (payload) => {
+        sendEvent(socket, {
+          type: "event",
+          instanceId: payload.instanceId,
+          workflowName: payload.workflowName,
+          timestamp: Date.now(),
+          event: payload.event,
+          data: payload.data,
+        });
+      },
+      emitLog: async (payload) => {
+        sendEvent(socket, {
+          type: "log",
+          instanceId: payload.instanceId,
+          workflowName: payload.workflowName,
+          timestamp: Date.now(),
+          level: payload.level,
+          message: payload.message,
+          data: payload.data,
+        });
+      },
     });
 
     sendEvent(socket, {

package/src/core/workflow-socket.ts

@@ -11,6 +11,8 @@ import { createServer as createNetServer } from "node:net";
 // Message Protocol Types
 // ============================================
 
+import type { LogLevel } from "./logger";
+
 export type WorkflowEventType =
   | "ready"
   | "started"
@@ -20,11 +22,14 @@ export type WorkflowEventType =
   | "step.failed"
   | "progress"
   | "completed"
-  | "failed";
+  | "failed"
+  | "event"
+  | "log";
 
 export interface WorkflowEvent {
   type: WorkflowEventType;
   instanceId: string;
+  workflowName?: string;
   timestamp: number;
   stepName?: string;
   /** Step type (for step.started events) */
@@ -36,6 +41,14 @@ export interface WorkflowEvent {
   totalSteps?: number;
   /** Next step to execute (for step.completed events) */
   nextStep?: string;
+  /** Custom event name (for event type) */
+  event?: string;
+  /** Custom event payload or log data */
+  data?: Record<string, any>;
+  /** Log level (for log type) */
+  level?: LogLevel;
+  /** Log message (for log type) */
+  message?: string;
 }
 
 export interface ProxyRequest {

package/src/core/workflow-state-machine.ts

@@ -45,6 +45,19 @@ export interface StateMachineConfig {
   jobs?: Jobs;
   /** Poll interval for checking job completion (ms) */
   pollInterval?: number;
+  emitCustomEvent?: (payload: {
+    instanceId: string;
+    workflowName: string;
+    event: string;
+    data?: Record<string, any>;
+  }) => Promise<void>;
+  emitLog?: (payload: {
+    instanceId: string;
+    workflowName: string;
+    level: LogLevel;
+    message: string;
+    data?: Record<string, any>;
+  }) => Promise<void>;
 }
 
 // ============================================
@@ -58,6 +71,8 @@ export class WorkflowStateMachine {
   private events: StateMachineEvents;
   private jobs?: Jobs;
   private pollInterval: number;
+  private emitCustomEvent?: StateMachineConfig["emitCustomEvent"];
+  private emitLog?: StateMachineConfig["emitLog"];
   private cancelledInstances = new Set<string>();
 
   constructor(config: StateMachineConfig) {
@@ -67,6 +82,8 @@ export class WorkflowStateMachine {
     this.events = config.events;
     this.jobs = config.jobs;
     this.pollInterval = config.pollInterval ?? 1000;
+    this.emitCustomEvent = config.emitCustomEvent;
+    this.emitLog = config.emitLog;
   }
 
   /**
@@ -484,26 +501,39 @@ export class WorkflowStateMachine {
     const instanceId = instance.id;
 
     const scopedLogger = this.core?.logger?.scoped("workflow", instance.id);
-    const emit = this.core?.events
-      ? async (event: string, data?: Record<string, any>) => {
-          const payload = {
-            instanceId: instance.id,
-            workflowName: instance.workflowName,
-            event,
-            data,
-          };
+    const emit = async (event: string, data?: Record<string, any>) => {
+      const payload = {
+        instanceId: instance.id,
+        workflowName: instance.workflowName,
+        event,
+        data,
+      };
 
-          await this.core!.events.emit("workflow.event", payload);
-          await this.core!.events.emit(`workflow.${instance.workflowName}.event`, payload);
-          await this.core!.events.emit(`workflow.${instance.id}.event`, payload);
-        }
-      : undefined;
+      if (this.core?.events) {
+        await this.core.events.emit("workflow.event", payload);
+        await this.core.events.emit(`workflow.${instance.workflowName}.event`, payload);
+        await this.core.events.emit(`workflow.${instance.id}.event`, payload);
+      }
 
-    const log = scopedLogger
-      ? (level: LogLevel, message: string, data?: Record<string, any>) => {
-          scopedLogger[level](message, data);
-        }
-      : undefined;
+      if (this.emitCustomEvent) {
+        await this.emitCustomEvent(payload);
+      }
+    };
+
+    const log = (level: LogLevel, message: string, data?: Record<string, any>) => {
+      if (scopedLogger) {
+        scopedLogger[level](message, data);
+      }
+      if (this.emitLog) {
+        return this.emitLog({
+          instanceId: instance.id,
+          workflowName: instance.workflowName,
+          level,
+          message,
+          data,
+        });
+      }
+    };
 
     const core = this.core
       ? {

package/src/core/workflows.ts

@@ -1475,6 +1475,70 @@ class WorkflowsImpl implements Workflows {
         break;
       }
 
+      case "event": {
+        const workflowName = event.workflowName ?? (await this.adapter.getInstance(instanceId))?.workflowName;
+        const payload = {
+          instanceId,
+          workflowName,
+          event: event.event,
+          data: event.data,
+        };
+
+        const ssePayload = {
+          id: `workflow_event_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          event: event.event,
+          stepName: event.data?.stepName,
+          data: event.data,
+          createdAt: new Date().toISOString(),
+        };
+
+        await this.emitEvent("workflow.event", payload);
+        if (workflowName) {
+          await this.emitEvent(`workflow.${workflowName}.event`, payload);
+        }
+        await this.emitEvent(`workflow.${instanceId}.event`, payload);
+
+        if (this.sse) {
+          this.sse.broadcast(`workflow:${instanceId}`, "event", ssePayload);
+          this.sse.broadcast("workflows:all", "workflow.event", {
+            ...ssePayload,
+            instanceId,
+            workflowName,
+          });
+        }
+        break;
+      }
+
+      case "log": {
+        const workflowName = event.workflowName ?? (await this.adapter.getInstance(instanceId))?.workflowName;
+
+        const ssePayload = {
+          id: `workflow_log_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+          level: event.level,
+          event: "log",
+          stepName: event.data?.stepName,
+          message: event.message,
+          data: event.data,
+          createdAt: new Date().toISOString(),
+        };
+
+        if (this.core?.logs && event.level && event.message) {
+          this.core.logs.write({
+            level: event.level,
+            message: event.message,
+            source: "workflow",
+            sourceId: instanceId,
+            data: event.data,
+            context: workflowName ? { workflowName } : undefined,
+          });
+        }
+
+        if (this.sse) {
+          this.sse.broadcast(`workflow:${instanceId}`, "log", ssePayload);
+        }
+        break;
+      }
+
       case "completed": {
         // Clean up isolated process tracking
         this.cleanupIsolatedProcess(instanceId);