trigger.dev 3.0.0-beta.3 → 3.0.0-beta.30

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

@@ -3,9 +3,9 @@ import {
   CoordinatorToProdWorkerMessages,
   PostStartCauses,
   PreStopCauses,
-  ProdWorkerToCoordinatorMessages,
-  ZodSocketConnection as ZodSocketConnection2
+  ProdWorkerToCoordinatorMessages
 } from "@trigger.dev/core/v3";
+import { ZodSocketConnection as ZodSocketConnection2 } from "@trigger.dev/core/v3/zodSocket";
 
 // ../core-apps/src/http.ts
 var HttpReply = class {
@@ -71,10 +71,10 @@ import {
   clientWebsocketMessages,
   PlatformToProviderMessages,
   ProviderToPlatformMessages,
-  SharedQueueToClientMessages,
-  ZodMessageSender,
-  ZodSocketConnection
+  SharedQueueToClientMessages
 } from "@trigger.dev/core/v3";
+import { ZodMessageSender } from "@trigger.dev/core/v3/zodMessageHandler";
+import { ZodSocketConnection } from "@trigger.dev/core/v3/zodSocket";
 var HTTP_SERVER_PORT = Number(process.env.HTTP_SERVER_PORT || getRandomPortNumber());
 var MACHINE_NAME = process.env.MACHINE_NAME || "local";
 var PLATFORM_HOST = process.env.PLATFORM_HOST || "127.0.0.1";
@@ -93,9 +93,9 @@ import {
   ProdWorkerToChildMessages,
   SemanticInternalAttributes,
   TaskRunErrorCodes,
-  ZodIpcConnection,
   correctErrorStackTrace
 } from "@trigger.dev/core/v3";
+import { ZodIpcConnection } from "@trigger.dev/core/v3/zodIpc";
 import { Evt } from "evt";
 import { fork } from "node:child_process";
 
@@ -108,6 +108,14 @@ var UncaughtExceptionError = class extends Error {
     this.name = "UncaughtExceptionError";
   }
 };
+var TaskMetadataParseError = class extends Error {
+  constructor(zodIssues, tasks) {
+    super(`Failed to parse task metadata`);
+    this.zodIssues = zodIssues;
+    this.tasks = tasks;
+    this.name = "TaskMetadataParseError";
+  }
+};
 
 // src/workers/prod/backgroundWorker.ts
 var UnexpectedExitError = class extends Error {
@@ -140,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();
@@ -206,6 +215,14 @@ var ProdBackgroundWorker = class {
               reject(new UncaughtExceptionError(message.error, message.origin));
               child.kill();
             }
+          },
+          TASKS_FAILED_TO_PARSE: async (message) => {
+            if (!resolved) {
+              clearTimeout(timeout);
+              resolved = true;
+              reject(new TaskMetadataParseError(message.zodIssues, message.tasks));
+              child.kill();
+            }
           }
         }
       });
@@ -247,6 +264,7 @@ var ProdBackgroundWorker = class {
     );
     if (!this._taskRunProcess) {
       const taskRunProcess = new TaskRunProcess(
+        payload.execution,
         this.path,
         {
           ...this.params.env,
@@ -279,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;
     }
@@ -289,7 +310,6 @@ var ProdBackgroundWorker = class {
     try {
       const taskRunProcess = await this.#initializeTaskRunProcess(payload);
       const result = await taskRunProcess.executeTaskRun(payload);
-      await taskRunProcess.cleanup(result.ok || result.retry === void 0);
       if (result.ok) {
         return result;
       }
@@ -358,7 +378,8 @@ var ProdBackgroundWorker = class {
   }
 };
 var TaskRunProcess = class {
-  constructor(path, env, metadata, worker) {
+  constructor(execution, path, env, metadata, worker) {
+    this.execution = execution;
     this.path = path;
     this.env = env;
     this.metadata = metadata;
@@ -377,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() {
@@ -391,6 +413,7 @@ var TaskRunProcess = class {
         "ipc"
       ],
       env: {
+        ...this.execution.run.isTest ? { TRIGGER_LOG_LEVEL: "debug" } : {},
         ...this.env,
         OTEL_RESOURCE_ATTRIBUTES: JSON.stringify({
           [SemanticInternalAttributes.PROJECT_DIR]: this.worker.projectConfig.projectDir
@@ -418,28 +441,56 @@ var TaskRunProcess = class {
           resolver(result);
         },
         READY_TO_DISPOSE: async (message) => {
+          process.exit(0);
         },
         TASK_HEARTBEAT: async (message) => {
           this.onTaskHeartbeat.post(message.id);
         },
         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
+            };
+          }
         }
       }
     });
@@ -558,6 +609,7 @@ var logger2 = new SimpleLogger(`[${MACHINE_NAME2}][${SHORT_HASH}]`);
 var ProdWorker = class {
   constructor(port, host = "0.0.0.0") {
     this.host = host;
+    process.on("SIGTERM", this.#handleSignal.bind(this, "SIGTERM"));
     this.#coordinatorSocket = this.#createCoordinatorSocket(COORDINATOR_HOST);
     this.#backgroundWorker = new ProdBackgroundWorker("worker.js", {
       projectConfig: __PROJECT_CONFIG__,
@@ -573,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) {
@@ -650,40 +710,66 @@ var ProdWorker = class {
   #backgroundWorker;
   #httpServer;
   #coordinatorSocket;
-  async #reconnect(isPostStart = false) {
+  async #handleSignal(signal) {
+    logger2.log("Received signal", { signal });
+    if (signal === "SIGTERM") {
+      if (this.executing) {
+        const terminationGracePeriodSeconds = 60 * 60;
+        logger2.log("Waiting for attempt to complete before exiting", {
+          terminationGracePeriodSeconds
+        });
+        await setTimeout2(terminationGracePeriodSeconds * 1e3 - 5e3);
+        logger2.log("Termination timeout reached, exiting gracefully.");
+      } else {
+        logger2.log("Not executing, exiting immediately.");
+      }
+      await this.#exitGracefully();
+    }
+    logger2.log("Unhandled signal", { signal });
+  }
+  async #exitGracefully() {
+    await this.#backgroundWorker.close();
+    process.exit(0);
+  }
+  async #reconnect(isPostStart = false, reconnectImmediately = false) {
     if (isPostStart) {
       this.waitForPostStart = false;
     }
     this.#coordinatorSocket.close();
-    if (!this.runningInKubernetes) {
-      this.#coordinatorSocket.connect();
-      return;
+    if (!reconnectImmediately) {
+      await setTimeout2(1e3);
     }
+    let coordinatorHost = COORDINATOR_HOST;
     try {
-      const coordinatorHost = (await readFile("/etc/taskinfo/coordinator-host", "utf-8")).replace(
-        "\n",
-        ""
-      );
-      logger2.log("reconnecting", {
-        coordinatorHost: {
-          fromEnv: COORDINATOR_HOST,
-          fromVolume: coordinatorHost,
-          current: this.#coordinatorSocket.socket.io.opts.hostname
-        }
-      });
-      this.#coordinatorSocket = this.#createCoordinatorSocket(coordinatorHost);
+      if (this.runningInKubernetes) {
+        coordinatorHost = (await readFile("/etc/taskinfo/coordinator-host", "utf-8")).replace(
+          "\n",
+          ""
+        );
+        logger2.log("reconnecting", {
+          coordinatorHost: {
+            fromEnv: COORDINATOR_HOST,
+            fromVolume: coordinatorHost,
+            current: this.#coordinatorSocket.socket.io.opts.hostname
+          }
+        });
+      }
     } catch (error) {
       logger2.error("taskinfo read error during reconnect", { error });
-      this.#coordinatorSocket.connect();
+    } finally {
+      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) {
@@ -692,8 +778,7 @@ var ProdWorker = class {
       if (willCheckpointAndRestore) {
         logger2.log("WARNING: Will checkpoint but also requested exit. This won't end well.");
       }
-      await this.#backgroundWorker.close();
-      process.exit(0);
+      await this.#exitGracefully();
     }
     this.executing = false;
     this.attemptFriendlyId = void 0;
@@ -706,6 +791,7 @@ var ProdWorker = class {
   #resumeAfterDuration() {
     this.paused = false;
     this.nextResumeAfter = void 0;
+    this.waitForPostStart = false;
     this.#backgroundWorker.waitCompletedNotification();
   }
   #returnValidatedExtraHeaders(headers) {
@@ -716,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,
@@ -780,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];
@@ -817,7 +905,6 @@ var ProdWorker = class {
           const completion = await this.#backgroundWorker.executeTaskRun(executionPayload);
           logger2.log("completed", completion);
           this.completed.add(executionPayload.execution.attempt.id);
-          await this.#backgroundWorker.flushTelemetry();
           const { willCheckpointAndRestore, shouldExit } = await this.#coordinatorSocket.socket.emitWithAck("TASK_RUN_COMPLETED", {
             version: "v1",
             execution: executionPayload.execution,
@@ -852,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();
@@ -868,30 +970,46 @@ var ProdWorker = class {
               process.exit(1);
             }
           } catch (e) {
-            if (e instanceof UncaughtExceptionError) {
-              logger3.error("uncaught exception", { message: e.originalError.message });
+            if (e instanceof TaskMetadataParseError) {
+              logger3.error("tasks metadata parse error", {
+                zodIssues: e.zodIssues,
+                tasks: e.tasks
+              });
               socket.emit("INDEXING_FAILED", {
                 version: "v1",
                 deploymentId: this.deploymentId,
                 error: {
-                  name: e.originalError.name,
-                  message: e.originalError.message,
-                  stack: e.originalError.stack
+                  name: "TaskMetadataParseError",
+                  message: "There was an error parsing the task metadata",
+                  stack: JSON.stringify({ zodIssues: e.zodIssues, tasks: e.tasks })
                 }
               });
+            } else if (e instanceof UncaughtExceptionError) {
+              const error = {
+                name: e.originalError.name,
+                message: e.originalError.message,
+                stack: e.originalError.stack
+              };
+              logger3.error("uncaught exception", { originalError: error });
+              socket.emit("INDEXING_FAILED", {
+                version: "v1",
+                deploymentId: this.deploymentId,
+                error
+              });
             } else if (e instanceof Error) {
-              logger3.error("error", { message: e.message });
+              const error = {
+                name: e.name,
+                message: e.message,
+                stack: e.stack
+              };
+              logger3.error("error", { error });
               socket.emit("INDEXING_FAILED", {
                 version: "v1",
                 deploymentId: this.deploymentId,
-                error: {
-                  name: e.name,
-                  message: e.message,
-                  stack: e.stack
-                }
+                error
               });
             } else if (typeof e === "string") {
-              logger3.error("string error", { message: e });
+              logger3.error("string error", { error: { message: e } });
               socket.emit("INDEXING_FAILED", {
                 version: "v1",
                 deploymentId: this.deploymentId,
@@ -912,27 +1030,8 @@ var ProdWorker = class {
               });
             }
             await setTimeout2(200);
-            process.exit(1);
-          }
-        }
-        if (this.paused) {
-          if (!this.nextResumeAfter) {
-            return;
-          }
-          if (!this.attemptFriendlyId) {
-            logger3.error("Missing friendly ID");
-            return;
+            process.exit(111);
           }
-          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;
@@ -970,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
             });
           }
@@ -1008,7 +1108,6 @@ var ProdWorker = class {
                 break;
               }
             }
-            logger2.log("preStop", { url: req.url });
             return reply.text("preStop ok");
           }
           case "/postStart": {
@@ -1025,7 +1124,7 @@ var ProdWorker = class {
                 break;
               }
               case "restore": {
-                await this.#reconnect(true);
+                await this.#reconnect(true, true);
                 break;
               }
               default: {

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

@@ -2,24 +2,30 @@
 import {
   ProdChildToWorkerMessages,
   ProdWorkerToChildMessages,
+  clock,
+  taskCatalog
+} from "@trigger.dev/core/v3";
+import {
   TaskExecutor,
-  ZodIpcConnection,
   DurableClock,
-  clock
-} from "@trigger.dev/core/v3";
+  getEnvVar,
+  logLevels,
+  OtelTaskLogger,
+  ConsoleInterceptor
+} from "@trigger.dev/core/v3/workers";
+import { ZodIpcConnection } from "@trigger.dev/core/v3/zodIpc";
+import { ZodSchemaParsedError } from "@trigger.dev/core/v3/zodMessageHandler";
 import "source-map-support/register.js";
 import {
-  ConsoleInterceptor,
-  OtelTaskLogger,
-  ProdRuntimeManager,
   TaskRunErrorCodes,
   TriggerTracer,
   logger,
   runtime
 } from "@trigger.dev/core/v3";
+import { ProdRuntimeManager } from "@trigger.dev/core/v3/prod";
 
 // package.json
-var version = "3.0.0-beta.3";
+var version = "3.0.0-beta.30";
 
 // src/workers/prod/worker-facade.ts
 __WORKER_SETUP__;
@@ -29,60 +35,33 @@ var otelLogger = tracingSDK.getLogger("trigger-prod-worker", version);
 var durableClock = new DurableClock();
 clock.setGlobalClock(durableClock);
 var tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
-var consoleInterceptor = new ConsoleInterceptor(otelLogger);
+var consoleInterceptor = new ConsoleInterceptor(otelLogger, true);
+var triggerLogLevel = getEnvVar("TRIGGER_LOG_LEVEL");
+var configLogLevel = triggerLogLevel ? triggerLogLevel : importedConfig ? importedConfig.logLevel : __PROJECT_CONFIG__.logLevel;
 var otelTaskLogger = new OtelTaskLogger({
   logger: otelLogger,
   tracer,
-  level: "info"
+  level: logLevels.includes(configLogLevel) ? configLogLevel : "info"
 });
 logger.setGlobalTaskLogger(otelTaskLogger);
 var TaskFileImports = {};
 var TaskFiles = {};
 __TASKS__;
-function getTasks() {
-  const result = [];
+(() => {
   for (const [importName, taskFile] of Object.entries(TaskFiles)) {
     const fileImports = TaskFileImports[importName];
     for (const [exportName, task] of Object.entries(fileImports ?? {})) {
-      if (task.__trigger) {
-        result.push({
-          id: task.__trigger.id,
-          exportName,
-          packageVersion: task.__trigger.packageVersion,
-          filePath: taskFile.filePath,
-          queue: task.__trigger.queue,
-          retry: task.__trigger.retry,
-          machine: task.__trigger.machine,
-          fns: task.__trigger.fns
-        });
+      if (typeof task === "object" && task !== null && "id" in task && typeof task.id === "string") {
+        if (taskCatalog.taskExists(task.id)) {
+          taskCatalog.registerTaskFileMetadata(task.id, {
+            exportName,
+            filePath: taskFile.filePath
+          });
+        }
       }
     }
   }
-  return result;
-}
-function getTaskMetadata() {
-  const result = getTasks();
-  return result.map((task) => {
-    const { fns, ...metadata } = task;
-    return metadata;
-  });
-}
-var tasks = getTasks();
-runtime.registerTasks(tasks);
-var taskExecutors = /* @__PURE__ */ new Map();
-for (const task of tasks) {
-  taskExecutors.set(
-    task.id,
-    new TaskExecutor(task, {
-      tracer,
-      tracingSDK,
-      consoleInterceptor,
-      projectConfig: __PROJECT_CONFIG__,
-      importedConfig,
-      handleErrorFn: handleError
-    })
-  );
-}
+})();
 var _execution;
 var _isRunning = false;
 var zodIpc = new ZodIpcConnection({
@@ -97,7 +76,7 @@ var zodIpc = new ZodIpcConnection({
           execution,
           result: {
             ok: false,
-            id: execution.attempt.id,
+            id: execution.run.id,
             error: {
               type: "INTERNAL_ERROR",
               code: TaskRunErrorCodes.TASK_ALREADY_RUNNING
@@ -107,14 +86,14 @@ var zodIpc = new ZodIpcConnection({
         return;
       }
       process.title = `trigger-prod-worker: ${execution.task.id} ${execution.run.id}`;
-      const executor = taskExecutors.get(execution.task.id);
-      if (!executor) {
-        console.error(`Could not find executor for task ${execution.task.id}`);
+      const task = taskCatalog.getTask(execution.task.id);
+      if (!task) {
+        console.error(`Could not find task ${execution.task.id}`);
         await sender.send("TASK_RUN_COMPLETED", {
           execution,
           result: {
             ok: false,
-            id: execution.attempt.id,
+            id: execution.run.id,
             error: {
               type: "INTERNAL_ERROR",
               code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR
@@ -123,6 +102,14 @@ var zodIpc = new ZodIpcConnection({
         });
         return;
       }
+      const executor = new TaskExecutor(task, {
+        tracer,
+        tracingSDK,
+        consoleInterceptor,
+        projectConfig: __PROJECT_CONFIG__,
+        importedConfig,
+        handleErrorFn: handleError
+      });
       try {
         _execution = execution;
         _isRunning = true;
@@ -140,11 +127,25 @@ var zodIpc = new ZodIpcConnection({
       prodRuntimeManager.resumeTask(completion, execution);
     },
     WAIT_COMPLETED_NOTIFICATION: async () => {
-      prodRuntimeManager.resumeAfterRestore();
+      prodRuntimeManager.resumeAfterDuration();
     },
     CLEANUP: async ({ flush, kill }, sender) => {
       if (kill) {
         await tracingSDK.flush();
+        if (_execution) {
+          await sender.send("TASK_RUN_COMPLETED", {
+            execution: _execution,
+            result: {
+              ok: false,
+              id: _execution.run.id,
+              error: {
+                type: "INTERNAL_ERROR",
+                code: TaskRunErrorCodes.GRACEFUL_EXIT_TIMEOUT,
+                message: "Worker process killed while attempt in progress."
+              }
+            }
+          });
+        }
         await sender.send("READY_TO_DISPOSE", void 0);
       } else {
         if (flush) {
@@ -154,12 +155,19 @@ var zodIpc = new ZodIpcConnection({
     }
   }
 });
+process.on("SIGTERM", async () => {
+});
 var prodRuntimeManager = new ProdRuntimeManager(zodIpc, {
   waitThresholdInMs: parseInt(process.env.TRIGGER_RUNTIME_WAIT_THRESHOLD_IN_MS ?? "30000", 10)
 });
 runtime.setGlobalRuntimeManager(prodRuntimeManager);
-zodIpc.send("TASKS_READY", { tasks: getTaskMetadata() }).catch((err) => {
-  console.error("Failed to send TASKS_READY message", err);
+var TASK_METADATA = taskCatalog.getAllTaskMetadata();
+zodIpc.send("TASKS_READY", { tasks: TASK_METADATA }).catch((err) => {
+  if (err instanceof ZodSchemaParsedError) {
+    zodIpc.send("TASKS_FAILED_TO_PARSE", { zodIssues: err.error.issues, tasks: TASK_METADATA });
+  } else {
+    console.error("Failed to send TASKS_READY message", err);
+  }
 });
 process.title = "trigger-prod-worker";
 async function asyncHeartbeat(initialDelayInSeconds = 30, intervalInSeconds = 5) {