also parse execute errors in deployed worker

Author: nicktrn

packages/cli-v3/src/dev/backgroundWorker.ts

@@ -3,7 +3,6 @@ import {
   CreateBackgroundWorkerResponse,
   ServerBackgroundWorker,
   TaskRunBuiltInError,
-  TaskRunErrorCodes,
   TaskRunExecution,
   TaskRunExecutionPayload,
   TaskRunExecutionResult,
@@ -14,13 +13,7 @@ import {
 import { Evt } from "evt";
 
 import { join } from "node:path";
-import {
-  CancelledProcessError,
-  CleanupProcessError,
-  SigKillTimeoutProcessError,
-  UnexpectedExitError,
-  getFriendlyErrorMessage,
-} from "@trigger.dev/core/v3/errors";
+import { SigKillTimeoutProcessError } from "@trigger.dev/core/v3/errors";
 import { TaskRunProcess, TaskRunProcessOptions } from "../executions/taskRunProcess.js";
 import { indexWorkerManifest } from "../indexing/indexWorkerManifest.js";
 import { prettyError } from "../utilities/cliOutput.js";
@@ -490,7 +483,7 @@ export class BackgroundWorker {
       const error = result.error;
 
       if (error.type === "BUILT_IN_ERROR") {
-        const mappedError = await this.#correctError(error, payload.execution);
+        const mappedError = await this.#correctError(error);
 
         return {
           ...result,
@@ -500,61 +493,16 @@ export class BackgroundWorker {
 
       return result;
     } catch (e) {
-      if (e instanceof CancelledProcessError) {
-        return {
-          id: payload.execution.run.id,
-          ok: false,
-          retry: undefined,
-          error: {
-            type: "INTERNAL_ERROR",
-            code: TaskRunErrorCodes.TASK_RUN_CANCELLED,
-          },
-        };
-      }
-
-      if (e instanceof CleanupProcessError) {
-        return {
-          id: payload.execution.run.id,
-          ok: false,
-          retry: undefined,
-          error: {
-            type: "INTERNAL_ERROR",
-            code: TaskRunErrorCodes.TASK_EXECUTION_ABORTED,
-          },
-        };
-      }
-
-      if (e instanceof UnexpectedExitError) {
-        return {
-          id: payload.execution.run.id,
-          ok: false,
-          retry: undefined,
-          error: {
-            type: "INTERNAL_ERROR",
-            code: TaskRunErrorCodes.TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE,
-            message: getFriendlyErrorMessage(e.code, e.signal, e.stderr),
-            stackTrace: e.stderr,
-          },
-        };
-      }
-
       return {
         id: payload.execution.run.id,
         ok: false,
         retry: undefined,
-        error: {
-          type: "INTERNAL_ERROR",
-          code: TaskRunErrorCodes.TASK_EXECUTION_FAILED,
-          message: String(e),
-        },
+        error: TaskRunProcess.parseExecuteError(e),
       };
     }
   }
 
-  async #correctError(
-    error: TaskRunBuiltInError,
-    execution: TaskRunExecution
-  ): Promise<TaskRunBuiltInError> {
+  async #correctError(error: TaskRunBuiltInError): Promise<TaskRunBuiltInError> {
     return {
       ...error,
       stackTrace: correctErrorStackTrace(error.stackTrace, this.params.cwd),

packages/cli-v3/src/entryPoints/deploy-run-controller.ts

@@ -784,7 +784,22 @@ class ProdWorker {
               error,
             });
 
-            this.#failRun(message.lazyPayload.runId, error);
+            try {
+              await this._taskRunProcess.cancel();
+            } catch (error) {
+              logger.error("Failed to cancel task run process", { error });
+            }
+
+            try {
+              await this.#submitAttemptCompletion(execution, {
+                id: execution.run.id,
+                ok: false,
+                retry: undefined,
+                error: TaskRunProcess.parseExecuteError(error),
+              });
+            } catch (error) {
+              this.#failRun(message.lazyPayload.runId, error);
+            }
           }
         },
         REQUEST_ATTEMPT_CANCELLATION: async (message) => {

packages/cli-v3/src/executions/taskRunProcess.ts

@@ -1,9 +1,11 @@
 import {
   ExecutorToWorkerMessageCatalog,
   ServerBackgroundWorker,
+  TaskRunErrorCodes,
   TaskRunExecution,
   TaskRunExecutionPayload,
   TaskRunExecutionResult,
+  type TaskRunInternalError,
   WorkerManifest,
   WorkerToExecutorMessageCatalog,
 } from "@trigger.dev/core/v3";
@@ -21,10 +23,10 @@ import { logger } from "../utilities/logger.js";
 import {
   CancelledProcessError,
   CleanupProcessError,
+  getFriendlyErrorMessage,
   GracefulExitTimeoutError,
   UnexpectedExitError,
 } from "@trigger.dev/core/v3/errors";
-import { env } from "std-env";
 
 export type OnWaitForDurationMessage = InferSocketMessageSchema<
   typeof ExecutorToWorkerMessageCatalog,
@@ -383,6 +385,37 @@ export class TaskRunProcess {
   get pid() {
     return this._childPid;
   }
+
+  static parseExecuteError(error: unknown): TaskRunInternalError {
+    if (error instanceof CancelledProcessError) {
+      return {
+        type: "INTERNAL_ERROR",
+        code: TaskRunErrorCodes.TASK_RUN_CANCELLED,
+      };
+    }
+
+    if (error instanceof CleanupProcessError) {
+      return {
+        type: "INTERNAL_ERROR",
+        code: TaskRunErrorCodes.TASK_EXECUTION_ABORTED,
+      };
+    }
+
+    if (error instanceof UnexpectedExitError) {
+      return {
+        type: "INTERNAL_ERROR",
+        code: TaskRunErrorCodes.TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE,
+        message: getFriendlyErrorMessage(error.code, error.signal, error.stderr),
+        stackTrace: error.stderr,
+      };
+    }
+
+    return {
+      type: "INTERNAL_ERROR",
+      code: TaskRunErrorCodes.TASK_EXECUTION_FAILED,
+      message: String(error),
+    };
+  }
 }
 
 function executorArgs(workerManifest: WorkerManifest): string[] {