@donkeylabs/server 2.0.26 → 2.0.27

package/package.json

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

package/src/core/job-adapter-sqlite.ts

@@ -34,6 +34,7 @@ export class SqliteJobAdapter implements JobAdapter {
     this.ensureDir(dbPath);
 
     this.db = new Database(dbPath);
+    this.db.run("PRAGMA busy_timeout = 5000");
     this.init();
 
     // Start cleanup timer

package/src/core/logs-adapter-kysely.ts

@@ -80,6 +80,7 @@ export class KyselyLogsAdapter implements LogsAdapter {
     // Enable WAL mode for better concurrent read/write performance
     sqliteDb.exec("PRAGMA journal_mode = WAL");
     sqliteDb.exec("PRAGMA synchronous = NORMAL");
+    sqliteDb.exec("PRAGMA busy_timeout = 5000");
 
     this.db = new Kysely<Database>({
       dialect: new SqliteDialect({

package/src/core/process-adapter-sqlite.ts

@@ -52,6 +52,7 @@ export class SqliteProcessAdapter implements ProcessAdapter {
     this.ensureDir(dbPath);
 
     this.db = new Database(dbPath);
+    this.db.run("PRAGMA busy_timeout = 5000");
     this.init();
 
     // Start cleanup timer

package/src/core/workflows.ts

@@ -649,8 +649,12 @@ export interface WorkflowsConfig {
   heartbeatTimeout?: number;
   /** Timeout waiting for isolated subprocess readiness (ms, default: 10000) */
   readyTimeout?: number;
+  /** Resume strategy for orphaned workflows (default: "blocking") */
+  resumeStrategy?: WorkflowResumeStrategy;
 }
 
+export type WorkflowResumeStrategy = "blocking" | "background" | "skip";
+
 /** Options for registering a workflow */
 export interface WorkflowRegisterOptions {
   /**
@@ -687,7 +691,7 @@ export interface Workflows {
   /** Get all workflow instances with optional filtering (for admin dashboard) */
   getAllInstances(options?: GetAllWorkflowsOptions): Promise<WorkflowInstance[]>;
   /** Resume workflows after server restart */
-  resume(): Promise<void>;
+  resume(options?: { strategy?: WorkflowResumeStrategy }): Promise<void>;
   /** Stop the workflow service */
   stop(): Promise<void>;
   /** Set core services (called after initialization to resolve circular dependency) */
@@ -739,6 +743,7 @@ class WorkflowsImpl implements Workflows {
   private dbPath?: string;
   private heartbeatTimeoutMs: number;
   private readyTimeoutMs: number;
+  private resumeStrategy!: WorkflowResumeStrategy;
   private workflowModulePaths = new Map<string, string>();
   private isolatedProcesses = new Map<string, IsolatedProcessInfo>();
   private readyWaiters = new Map<
@@ -772,6 +777,7 @@ class WorkflowsImpl implements Workflows {
     this.dbPath = config.dbPath;
     this.heartbeatTimeoutMs = config.heartbeatTimeout ?? 60000;
     this.readyTimeoutMs = config.readyTimeout ?? 10000;
+    this.resumeStrategy = config.resumeStrategy ?? "blocking";
   }
 
   private getSocketServer(): WorkflowSocketServer {
@@ -975,38 +981,64 @@ class WorkflowsImpl implements Workflows {
     return this.adapter.getAllInstances(options);
   }
 
-  async resume(): Promise<void> {
+  async resume(options?: { strategy?: WorkflowResumeStrategy }): Promise<void> {
+    const strategy = options?.strategy ?? this.resumeStrategy;
     const running = await this.adapter.getRunningInstances();
 
-    for (const instance of running) {
+    if (this.dbPath) {
+      await this.getSocketServer().cleanOrphanedSockets(
+        new Set(running.map((instance) => instance.id))
+      );
+    }
+
+    if (strategy === "skip") {
+      await this.markOrphanedAsFailed(running, "Workflow resume skipped");
+      return;
+    }
+
+    const resumeInstance = async (instance: WorkflowInstance) => {
       const definition = this.definitions.get(instance.workflowName);
       if (!definition) {
-        // Workflow no longer registered, mark as failed
         await this.adapter.updateInstance(instance.id, {
           status: "failed",
           error: "Workflow definition not found after restart",
           completedAt: new Date(),
         });
-        continue;
+        return;
       }
 
       console.log(`[Workflows] Resuming workflow instance ${instance.id}`);
 
-      // Check isolation mode and call appropriate method
       const isIsolated = definition.isolated !== false;
       const modulePath = this.workflowModulePaths.get(instance.workflowName);
 
       if (isIsolated && modulePath && this.dbPath) {
-        try {
-          await this.executeIsolatedWorkflow(instance.id, definition, instance.input, modulePath);
-        } catch (error) {
+        await this.executeIsolatedWorkflow(instance.id, definition, instance.input, modulePath);
+      } else {
+        this.startInlineWorkflow(instance.id, definition);
+      }
+    };
+
+    if (strategy === "background") {
+      for (const instance of running) {
+        resumeInstance(instance).catch((error) => {
           console.error(
-            `[Workflows] Failed to resume isolated workflow ${instance.id}:`,
+            `[Workflows] Failed to resume workflow ${instance.id}:`,
             error instanceof Error ? error.message : String(error)
           );
-        }
-      } else {
-        this.startInlineWorkflow(instance.id, definition);
+        });
+      }
+      return;
+    }
+
+    for (const instance of running) {
+      try {
+        await resumeInstance(instance);
+      } catch (error) {
+        console.error(
+          `[Workflows] Failed to resume workflow ${instance.id}:`,
+          error instanceof Error ? error.message : String(error)
+        );
       }
     }
   }
@@ -1710,6 +1742,34 @@ class WorkflowsImpl implements Workflows {
     this.rejectIsolatedReady(instanceId, new Error("Isolated workflow cleaned up"));
   }
 
+  private async markOrphanedAsFailed(
+    instances: WorkflowInstance[],
+    reason: string
+  ): Promise<void> {
+    for (const instance of instances) {
+      await this.adapter.updateInstance(instance.id, {
+        status: "failed",
+        error: reason,
+        completedAt: new Date(),
+      });
+
+      await this.emitEvent("workflow.failed", {
+        instanceId: instance.id,
+        workflowName: instance.workflowName,
+        error: reason,
+      });
+
+      if (this.sse) {
+        this.sse.broadcast(`workflow:${instance.id}`, "failed", { error: reason });
+        this.sse.broadcast("workflows:all", "workflow.failed", {
+          instanceId: instance.id,
+          workflowName: instance.workflowName,
+          error: reason,
+        });
+      }
+    }
+  }
+
   /**
    * Reset heartbeat timeout for an isolated workflow
    */

package/src/server.ts

@@ -81,6 +81,11 @@ export interface ServerConfig {
   rateLimiter?: RateLimiterConfig;
   errors?: ErrorsConfig;
   workflows?: WorkflowsConfig;
+  /**
+   * Resume strategy for workflows on startup.
+   * Defaults to "blocking" for server mode and "background" for adapter mode.
+   */
+  workflowsResumeStrategy?: "blocking" | "background" | "skip";
   processes?: ProcessesConfig;
   audit?: AuditConfig;
   websocket?: WebSocketConfig;
@@ -214,6 +219,8 @@ export class AppServer {
   private isInitialized = false;
   private initializationPromise: Promise<void> | null = null;
   private generateModeSetup = false;
+  private initMode: "adapter" | "server" = "server";
+  private workflowsResumeStrategy?: "blocking" | "background" | "skip";
 
   // Custom services registry
   private serviceFactories = new Map<string, ServiceFactory<any>>();
@@ -225,6 +232,7 @@ export class AppServer {
     const envPort = process.env.PORT ? parseInt(process.env.PORT, 10) : undefined;
     this.port = options.port ?? envPort ?? 3000;
     this.maxPortAttempts = options.maxPortAttempts ?? 5;
+    this.workflowsResumeStrategy = options.workflowsResumeStrategy ?? options.workflows?.resumeStrategy;
 
     // Determine if we should use legacy databases
     const useLegacy = options.useLegacyCoreDatabases ?? false;
@@ -986,6 +994,7 @@ ${factoryFunction}
    * Used by adapters (e.g., SvelteKit) that manage their own HTTP server.
    */
   async initialize(): Promise<void> {
+    this.initMode = "adapter";
     // Handle CLI type generation mode - exit early before any initialization
     if (process.env.DONKEYLABS_GENERATE === "1") {
       this.outputRoutesForGeneration();
@@ -1038,7 +1047,13 @@ ${factoryFunction}
     this.coreServices.cron.start();
     this.coreServices.jobs.start();
     await this.coreServices.workflows.resolveDbPath();
-    await this.coreServices.workflows.resume();
+    const defaultStrategy = this.initMode === "adapter" ? "background" : undefined;
+    const strategy = this.workflowsResumeStrategy ?? defaultStrategy;
+    if (strategy) {
+      await this.coreServices.workflows.resume({ strategy });
+    } else {
+      await this.coreServices.workflows.resume();
+    }
     this.coreServices.processes.start();
     logger.info("Background services started (cron, jobs, workflows, processes)");
 
@@ -1252,6 +1267,7 @@ ${factoryFunction}
    * 5. Start the HTTP server
    */
   async start() {
+    this.initMode = "server";
     // Handle CLI type generation mode - exit early before any initialization
     if (process.env.DONKEYLABS_GENERATE === "1") {
       this.outputRoutesForGeneration();