@donkeylabs/server 2.0.21 → 2.0.23

package/src/core/workflow-executor.ts

@@ -1,18 +1,13 @@
 #!/usr/bin/env bun
 // Workflow Executor - Subprocess Entry Point
-// Thin shell that creates a WorkflowStateMachine with IPC event bridge.
-// The state machine owns all execution logic and persistence.
+// Bootstraps core services and plugins locally for isolated workflows.
 
 import { connect } from "node:net";
 import type { Socket } from "node:net";
-import { Kysely } from "kysely";
-import { BunSqliteDialect } from "kysely-bun-sqlite";
-import Database from "bun:sqlite";
 import type { WorkflowEvent } from "./workflow-socket";
-import { WorkflowProxyConnection, createPluginsProxy, createCoreServicesProxy } from "./workflow-proxy";
 import type { WorkflowDefinition } from "./workflows";
-import { KyselyWorkflowAdapter } from "./workflow-adapter-kysely";
 import { WorkflowStateMachine, type StateMachineEvents } from "./workflow-state-machine";
+import { bootstrapSubprocess } from "./subprocess-bootstrap";
 
 // ============================================
 // Types
@@ -26,6 +21,10 @@ interface ExecutorConfig {
   tcpPort?: number;
   modulePath: string;
   dbPath: string;
+  pluginNames: string[];
+  pluginModulePaths: Record<string, string>;
+  pluginConfigs: Record<string, any>;
+  coreConfig?: Record<string, any>;
 }
 
 // ============================================
@@ -37,19 +36,23 @@ async function main(): Promise<void> {
   const stdin = await Bun.stdin.text();
   const config: ExecutorConfig = JSON.parse(stdin);
 
-  const { instanceId, workflowName, socketPath, tcpPort, modulePath, dbPath } = config;
+  const {
+    instanceId,
+    workflowName,
+    socketPath,
+    tcpPort,
+    modulePath,
+    dbPath,
+    pluginNames,
+    pluginModulePaths,
+    pluginConfigs,
+    coreConfig,
+  } = config;
 
-  // Connect to IPC socket
   const socket = await connectToSocket(socketPath, tcpPort);
-  const proxyConnection = new WorkflowProxyConnection(socket);
 
-  // Create database connection + adapter (subprocess owns its own persistence)
-  const db = new Kysely<any>({
-    dialect: new BunSqliteDialect({
-      database: new Database(dbPath),
-    }),
-  });
-  const adapter = new KyselyWorkflowAdapter(db, { cleanupDays: 0 });
+  let cleanup: (() => Promise<void>) | undefined;
+  let exitCode = 0;
 
   // Start heartbeat
   const heartbeatInterval = setInterval(() => {
@@ -61,30 +64,41 @@ async function main(): Promise<void> {
   }, 5000);
 
   try {
-    // Send started event
-    sendEvent(socket, {
-      type: "started",
-      instanceId,
-      timestamp: Date.now(),
-    });
-
     // Import the workflow module to get the definition
     const module = await import(modulePath);
     const definition = findWorkflowDefinition(module, workflowName, modulePath);
 
-    // Create proxy objects for plugin/core access via IPC
-    const plugins = createPluginsProxy(proxyConnection);
-    const coreServices = createCoreServicesProxy(proxyConnection);
+    const bootstrap = await bootstrapSubprocess({
+      dbPath,
+      coreConfig,
+      pluginMetadata: {
+        names: pluginNames,
+        modulePaths: pluginModulePaths,
+        configs: pluginConfigs,
+      },
+    });
+    cleanup = bootstrap.cleanup;
+
+    sendEvent(socket, {
+      type: "ready",
+      instanceId,
+      timestamp: Date.now(),
+    });
 
-    // Create state machine with IPC event bridge
     const sm = new WorkflowStateMachine({
-      adapter,
-      core: { ...coreServices, db } as any,
-      plugins,
+      adapter: bootstrap.workflowAdapter,
+      core: bootstrap.core as any,
+      plugins: bootstrap.manager.getServices(),
       events: createIpcEventBridge(socket, instanceId),
       pollInterval: 1000,
     });
 
+    sendEvent(socket, {
+      type: "started",
+      instanceId,
+      timestamp: Date.now(),
+    });
+
     // Run the state machine to completion
     const result = await sm.run(instanceId, definition);
 
@@ -103,16 +117,16 @@ async function main(): Promise<void> {
       timestamp: Date.now(),
       error: error instanceof Error ? error.message : String(error),
     });
-    process.exit(1);
+    exitCode = 1;
   } finally {
     clearInterval(heartbeatInterval);
-    proxyConnection.close();
     socket.end();
-    adapter.stop();
-    await db.destroy();
+    if (cleanup) {
+      await cleanup();
+    }
   }
 
-  process.exit(0);
+  process.exit(exitCode);
 }
 
 // ============================================

package/src/core/workflow-socket.ts

@@ -12,6 +12,7 @@ import { createServer as createNetServer } from "node:net";
 // ============================================
 
 export type WorkflowEventType =
+  | "ready"
   | "started"
   | "heartbeat"
   | "step.started"

package/src/core/workflows.test.ts

@@ -412,6 +412,62 @@ describe("WorkflowDefinition", () => {
     expect(isolatedWf.isolated).toBe(true);
     expect(inlineWf.isolated).toBe(false);
   });
+
+  it("should auto-detect sourceModule as a valid file:// URL after build()", () => {
+    const wf = workflow("auto-detect")
+      .task("s", { handler: async () => 1 })
+      .build();
+
+    expect(wf.sourceModule).toBeDefined();
+    expect(wf.sourceModule).toMatch(/^file:\/\//);
+    // Should point to this test file
+    expect(wf.sourceModule).toContain("workflows.test.ts");
+  });
+});
+
+describe("register() with auto-detected sourceModule", () => {
+  let workflows: ReturnType<typeof createWorkflows>;
+  let adapter: MemoryWorkflowAdapter;
+
+  beforeEach(() => {
+    adapter = new MemoryWorkflowAdapter();
+    workflows = createWorkflows({ adapter });
+  });
+
+  afterEach(async () => {
+    await workflows.stop();
+  });
+
+  it("should not warn when registering isolated workflow with auto-detected sourceModule", () => {
+    const wf = workflow("auto-isolated")
+      .task("s", { handler: async () => 1 })
+      .build();
+
+    // sourceModule should be set by build()
+    expect(wf.sourceModule).toBeDefined();
+
+    const warnings: string[] = [];
+    const origWarn = console.warn;
+    console.warn = (...args: any[]) => warnings.push(args.join(" "));
+    try {
+      workflows.register(wf);
+    } finally {
+      console.warn = origWarn;
+    }
+
+    expect(warnings.filter((w) => w.includes("no modulePath"))).toHaveLength(0);
+  });
+
+  it("should prefer explicit modulePath over auto-detected sourceModule", () => {
+    const wf = workflow("explicit-path")
+      .task("s", { handler: async () => 1 })
+      .build();
+
+    // Register with explicit modulePath
+    expect(() => {
+      workflows.register(wf, { modulePath: "file:///explicit/path.ts" });
+    }).not.toThrow();
+  });
 });
 
 describe("Choice steps (inline)", () => {