trigger.dev 3.0.0-beta.23 → 3.0.0-beta.25

package/dist/workers/dev/worker-facade.js

@@ -25,7 +25,7 @@ import {
 } from "@trigger.dev/core/v3/zodMessageHandler";
 
 // package.json
-var version = "3.0.0-beta.23";
+var version = "3.0.0-beta.25";
 
 // src/workers/dev/worker-facade.ts
 __WORKER_SETUP__;

package/dist/workers/prod/entry-point.js

@@ -148,6 +148,7 @@ var ProdBackgroundWorker = class {
   onWaitForDuration = new Evt();
   onWaitForTask = new Evt();
   preCheckpointNotification = Evt.create();
+  checkpointCanceledNotification = Evt.create();
   onReadyForCheckpoint = Evt.create();
   onCancelCheckpoint = Evt.create();
   _onClose = new Evt();
@@ -296,6 +297,9 @@ var ProdBackgroundWorker = class {
       this.preCheckpointNotification.attach((message) => {
         taskRunProcess.preCheckpointNotification.post(message);
       });
+      this.checkpointCanceledNotification.attach((message) => {
+        taskRunProcess.checkpointCanceledNotification.post(message);
+      });
       await taskRunProcess.initialize();
       this._taskRunProcess = taskRunProcess;
     }
@@ -394,6 +398,7 @@ var TaskRunProcess = class {
   onWaitForDuration = new Evt();
   onWaitForTask = new Evt();
   preCheckpointNotification = Evt.create();
+  checkpointCanceledNotification = Evt.create();
   onReadyForCheckpoint = Evt.create();
   onCancelCheckpoint = Evt.create();
   async initialize() {
@@ -443,22 +448,49 @@ var TaskRunProcess = class {
         },
         TASKS_READY: async (message) => {
         },
+        WAIT_FOR_TASK: async (message) => {
+          this.onWaitForTask.post(message);
+        },
         WAIT_FOR_BATCH: async (message) => {
           this.onWaitForBatch.post(message);
         },
         WAIT_FOR_DURATION: async (message) => {
           this.onWaitForDuration.post(message);
-          const { willCheckpointAndRestore } = await this.preCheckpointNotification.waitFor();
-          return { willCheckpointAndRestore };
-        },
-        WAIT_FOR_TASK: async (message) => {
-          this.onWaitForTask.post(message);
+          try {
+            const { willCheckpointAndRestore } = await this.preCheckpointNotification.waitFor(
+              3e4
+            );
+            return {
+              willCheckpointAndRestore
+            };
+          } catch (error) {
+            console.error("Error while waiting for pre-checkpoint notification", error);
+            return {
+              willCheckpointAndRestore: false
+            };
+          }
         },
         READY_FOR_CHECKPOINT: async (message) => {
           this.onReadyForCheckpoint.post(message);
         },
         CANCEL_CHECKPOINT: async (message) => {
+          const version = "v2";
           this.onCancelCheckpoint.post(message);
+          try {
+            const { checkpointCanceled } = await this.checkpointCanceledNotification.waitFor(
+              3e4
+            );
+            return {
+              version,
+              checkpointCanceled
+            };
+          } catch (error) {
+            console.error("Error while waiting for checkpoint cancellation", error);
+            return {
+              version,
+              checkpointCanceled: true
+            };
+          }
         }
       }
     });
@@ -593,18 +625,26 @@ var ProdWorker = class {
       this.#coordinatorSocket.socket.emit("TASK_HEARTBEAT", { version: "v1", attemptFriendlyId });
     });
     this.#backgroundWorker.onReadyForCheckpoint.attach(async (message) => {
+      await this.#backgroundWorker.flushTelemetry();
       this.#coordinatorSocket.socket.emit("READY_FOR_CHECKPOINT", { version: "v1" });
     });
     this.#backgroundWorker.onCancelCheckpoint.attach(async (message) => {
-      logger2.log("onCancelCheckpoint() clearing paused state, don't wait for post start hook", {
-        paused: this.paused,
-        nextResumeAfter: this.nextResumeAfter,
-        waitForPostStart: this.waitForPostStart
-      });
-      this.paused = false;
-      this.nextResumeAfter = void 0;
-      this.waitForPostStart = false;
-      this.#coordinatorSocket.socket.emit("CANCEL_CHECKPOINT", { version: "v1" });
+      logger2.log("onCancelCheckpoint", { message });
+      const { checkpointCanceled } = await this.#coordinatorSocket.socket.emitWithAck(
+        "CANCEL_CHECKPOINT",
+        {
+          version: "v2",
+          reason: message.reason
+        }
+      );
+      if (checkpointCanceled) {
+        if (message.reason === "WAIT_FOR_DURATION") {
+          this.paused = false;
+          this.nextResumeAfter = void 0;
+          this.waitForPostStart = false;
+        }
+      }
+      this.#backgroundWorker.checkpointCanceledNotification.post({ checkpointCanceled });
     });
     this.#backgroundWorker.onWaitForDuration.attach(async (message) => {
       if (!this.attemptFriendlyId) {
@@ -720,13 +760,16 @@ var ProdWorker = class {
       this.#coordinatorSocket = this.#createCoordinatorSocket(coordinatorHost);
     }
   }
-  #prepareForWait(reason, willCheckpointAndRestore) {
+  async #prepareForWait(reason, willCheckpointAndRestore) {
     logger2.log(`prepare for ${reason}`, { willCheckpointAndRestore });
     this.#backgroundWorker.preCheckpointNotification.post({ willCheckpointAndRestore });
     if (willCheckpointAndRestore) {
       this.paused = true;
       this.nextResumeAfter = reason;
       this.waitForPostStart = true;
+      if (reason === "WAIT_FOR_TASK" || reason === "WAIT_FOR_BATCH") {
+        await this.#backgroundWorker.flushTelemetry();
+      }
     }
   }
   async #prepareForRetry(willCheckpointAndRestore, shouldExit) {
@@ -748,6 +791,7 @@ var ProdWorker = class {
   #resumeAfterDuration() {
     this.paused = false;
     this.nextResumeAfter = void 0;
+    this.waitForPostStart = false;
     this.#backgroundWorker.waitCompletedNotification();
   }
   #returnValidatedExtraHeaders(headers) {
@@ -758,6 +802,7 @@ var ProdWorker = class {
     }
     return headers;
   }
+  // FIXME: If the the worker can't connect for a while, this runs MANY times - it should only run once
   #createCoordinatorSocket(host) {
     const extraHeaders = this.#returnValidatedExtraHeaders({
       "x-machine-name": MACHINE_NAME2,
@@ -822,6 +867,7 @@ var ProdWorker = class {
           }
           this.paused = false;
           this.nextResumeAfter = void 0;
+          this.waitForPostStart = false;
           for (let i = 0; i < message.completions.length; i++) {
             const completion = message.completions[i];
             const execution = message.executions[i];
@@ -893,6 +939,21 @@ var ProdWorker = class {
           logger3.log("skip connection handler, waiting for post start hook");
           return;
         }
+        if (this.paused) {
+          if (!this.nextResumeAfter) {
+            return;
+          }
+          if (!this.attemptFriendlyId) {
+            logger3.error("Missing friendly ID");
+            return;
+          }
+          socket.emit("READY_FOR_RESUME", {
+            version: "v1",
+            attemptFriendlyId: this.attemptFriendlyId,
+            type: this.nextResumeAfter
+          });
+          return;
+        }
         if (process.env.INDEX_TASKS === "true") {
           try {
             const taskResources = await this.#initializeWorker();
@@ -972,25 +1033,6 @@ var ProdWorker = class {
             process.exit(111);
           }
         }
-        if (this.paused) {
-          if (!this.nextResumeAfter) {
-            return;
-          }
-          if (!this.attemptFriendlyId) {
-            logger3.error("Missing friendly ID");
-            return;
-          }
-          if (this.nextResumeAfter === "WAIT_FOR_DURATION") {
-            this.#resumeAfterDuration();
-            return;
-          }
-          socket.emit("READY_FOR_RESUME", {
-            version: "v1",
-            attemptFriendlyId: this.attemptFriendlyId,
-            type: this.nextResumeAfter
-          });
-          return;
-        }
         if (this.executing) {
           return;
         }
@@ -1027,7 +1069,8 @@ var ProdWorker = class {
           case "/status": {
             return reply.json({
               executing: this.executing,
-              pause: this.paused,
+              paused: this.paused,
+              completed: this.completed.size,
               nextResumeAfter: this.nextResumeAfter
             });
           }

package/dist/workers/prod/worker-facade.js

@@ -25,7 +25,7 @@ import {
 import { ProdRuntimeManager } from "@trigger.dev/core/v3/prod";
 
 // package.json
-var version = "3.0.0-beta.23";
+var version = "3.0.0-beta.25";
 
 // src/workers/prod/worker-facade.ts
 __WORKER_SETUP__;
@@ -127,7 +127,7 @@ var zodIpc = new ZodIpcConnection({
       prodRuntimeManager.resumeTask(completion, execution);
     },
     WAIT_COMPLETED_NOTIFICATION: async () => {
-      prodRuntimeManager.resumeAfterRestore();
+      prodRuntimeManager.resumeAfterDuration();
     },
     CLEANUP: async ({ flush, kill }, sender) => {
       if (kill) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "trigger.dev",
-  "version": "3.0.0-beta.23",
+  "version": "3.0.0-beta.25",
   "description": "A Command-Line Interface for Trigger.dev (v3) projects",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -53,8 +53,8 @@
     "typescript": "^5.3.3",
     "vitest": "^0.34.4",
     "xdg-app-paths": "^8.3.0",
-    "@trigger.dev/core-apps": "3.0.0-beta.23",
-    "@trigger.dev/tsconfig": "0.0.0"
+    "@trigger.dev/tsconfig": "0.0.0",
+    "@trigger.dev/core-apps": "3.0.0-beta.25"
   },
   "dependencies": {
     "@anatine/esbuild-decorators": "^0.2.19",
@@ -72,7 +72,7 @@
     "@opentelemetry/sdk-trace-base": "^1.22.0",
     "@opentelemetry/sdk-trace-node": "^1.22.0",
     "@opentelemetry/semantic-conventions": "^1.22.0",
-    "@trigger.dev/core": "3.0.0-beta.23",
+    "@trigger.dev/core": "3.0.0-beta.25",
     "@types/degit": "^2.8.3",
     "chalk": "^5.2.0",
     "chokidar": "^3.5.3",