trigger.dev 1.0.7 → 1.0.8

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

@@ -0,0 +1,1214 @@
+// src/workers/prod/entry-point.ts
+import {
+  CoordinatorToProdWorkerMessages,
+  PostStartCauses,
+  PreStopCauses,
+  ProdWorkerToCoordinatorMessages
+} from "@trigger.dev/core/v3";
+import { ZodSocketConnection as ZodSocketConnection2 } from "@trigger.dev/core/v3/zodSocket";
+
+// ../core-apps/src/http.ts
+var HttpReply = class {
+  constructor(response) {
+    this.response = response;
+  }
+  empty(status) {
+    return this.response.writeHead(status ?? 200).end();
+  }
+  text(text, status, contentType) {
+    return this.response.writeHead(status ?? 200, { "Content-Type": contentType || "text/plain" }).end(text.endsWith("\n") ? text : `${text}
+`);
+  }
+  json(value, pretty) {
+    return this.text(
+      JSON.stringify(value, void 0, pretty ? 2 : void 0),
+      200,
+      "application/json"
+    );
+  }
+};
+function getRandomInteger(min, max) {
+  const intMin = Math.ceil(min);
+  const intMax = Math.floor(max);
+  return Math.floor(Math.random() * (intMax - intMin + 1)) + intMin;
+}
+function getRandomPortNumber() {
+  return getRandomInteger(8e3, 9999);
+}
+
+// ../core-apps/src/logger.ts
+var SimpleLogger = class {
+  constructor(prefix) {
+    this.prefix = prefix;
+  }
+  #debugEnabled = ["1", "true"].includes(process.env.DEBUG ?? "");
+  log(arg0, ...argN) {
+    console.log(...this.#getPrefixedArgs(arg0, ...argN));
+    return arg0;
+  }
+  debug(arg0, ...argN) {
+    if (!this.#debugEnabled) {
+      return arg0;
+    }
+    console.debug(...this.#getPrefixedArgs("DEBUG", arg0, ...argN));
+    return arg0;
+  }
+  error(arg0, ...argN) {
+    console.error(...this.#getPrefixedArgs(arg0, ...argN));
+    return arg0;
+  }
+  #getPrefixedArgs(...args) {
+    if (!this.prefix) {
+      return args;
+    }
+    return [this.prefix, ...args];
+  }
+};
+
+// ../core-apps/src/provider.ts
+import {
+  ClientToSharedQueueMessages,
+  clientWebsocketMessages,
+  PlatformToProviderMessages,
+  ProviderToPlatformMessages,
+  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";
+var PLATFORM_WS_PORT = process.env.PLATFORM_WS_PORT || 3030;
+var PLATFORM_SECRET = process.env.PLATFORM_SECRET || "provider-secret";
+var SECURE_CONNECTION = ["1", "true"].includes(process.env.SECURE_CONNECTION ?? "false");
+var logger = new SimpleLogger(`[${MACHINE_NAME}]`);
+
+// src/workers/prod/entry-point.ts
+import { readFile } from "node:fs/promises";
+import { createServer } from "node:http";
+
+// src/workers/prod/backgroundWorker.ts
+import {
+  ProdChildToWorkerMessages,
+  ProdWorkerToChildMessages,
+  SemanticInternalAttributes,
+  TaskRunErrorCodes,
+  correctErrorStackTrace
+} from "@trigger.dev/core/v3";
+import { ZodIpcConnection } from "@trigger.dev/core/v3/zodIpc";
+import { Evt } from "evt";
+import { fork } from "node:child_process";
+
+// src/workers/common/errors.ts
+var UncaughtExceptionError = class extends Error {
+  constructor(originalError, origin) {
+    super(`Uncaught exception: ${originalError.message}`);
+    this.originalError = originalError;
+    this.origin = origin;
+    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 {
+  constructor(code) {
+    super(`Unexpected exit with code ${code}`);
+    this.code = code;
+    this.name = "UnexpectedExitError";
+  }
+};
+var CleanupProcessError = class extends Error {
+  constructor() {
+    super("Cancelled");
+    this.name = "CleanupProcessError";
+  }
+};
+var CancelledProcessError = class extends Error {
+  constructor() {
+    super("Cancelled");
+    this.name = "CancelledProcessError";
+  }
+};
+var ProdBackgroundWorker = class {
+  constructor(path, params) {
+    this.path = path;
+    this.params = params;
+  }
+  _initialized = false;
+  onTaskHeartbeat = new Evt();
+  onWaitForBatch = new Evt();
+  onWaitForDuration = new Evt();
+  onWaitForTask = new Evt();
+  preCheckpointNotification = Evt.create();
+  checkpointCanceledNotification = Evt.create();
+  onReadyForCheckpoint = Evt.create();
+  onCancelCheckpoint = Evt.create();
+  _onClose = new Evt();
+  tasks = [];
+  _taskRunProcess;
+  _closed = false;
+  async close() {
+    if (this._closed) {
+      return;
+    }
+    this._closed = true;
+    this.onTaskHeartbeat.detach();
+    await this._taskRunProcess?.cleanup(true);
+  }
+  async flushTelemetry() {
+    await this._taskRunProcess?.cleanup(false);
+  }
+  async initialize(options) {
+    if (this._initialized) {
+      throw new Error("Worker already initialized");
+    }
+    let resolved = false;
+    this.tasks = await new Promise((resolve, reject) => {
+      const child = fork(this.path, {
+        stdio: [
+          /*stdin*/
+          "ignore",
+          /*stdout*/
+          "pipe",
+          /*stderr*/
+          "pipe",
+          "ipc"
+        ],
+        env: {
+          ...this.params.env,
+          ...options?.env
+        }
+      });
+      const timeout = setTimeout(() => {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        child.kill();
+        reject(new Error("Worker timed out"));
+      }, 1e4);
+      new ZodIpcConnection({
+        listenSchema: ProdChildToWorkerMessages,
+        emitSchema: ProdWorkerToChildMessages,
+        process: child,
+        handlers: {
+          TASKS_READY: async (message) => {
+            if (!resolved) {
+              clearTimeout(timeout);
+              resolved = true;
+              resolve(message.tasks);
+              child.kill();
+            }
+          },
+          UNCAUGHT_EXCEPTION: async (message) => {
+            if (!resolved) {
+              clearTimeout(timeout);
+              resolved = true;
+              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();
+            }
+          }
+        }
+      });
+      child.stdout?.on("data", (data) => {
+        console.log(data.toString());
+      });
+      child.stderr?.on("data", (data) => {
+        console.error(data.toString());
+      });
+      child.on("exit", (code) => {
+        if (!resolved) {
+          clearTimeout(timeout);
+          resolved = true;
+          reject(new Error(`Worker exited with code ${code}`));
+        }
+      });
+    });
+    this._initialized = true;
+  }
+  getMetadata(workerId, version) {
+    return {
+      contentHash: this.params.contentHash,
+      id: workerId,
+      version
+    };
+  }
+  // We need to notify all the task run processes that a task run has completed,
+  // in case they are waiting for it through triggerAndWait
+  async taskRunCompletedNotification(completion, execution) {
+    this._taskRunProcess?.taskRunCompletedNotification(completion, execution);
+  }
+  async waitCompletedNotification() {
+    this._taskRunProcess?.waitCompletedNotification();
+  }
+  async #initializeTaskRunProcess(payload) {
+    const metadata = this.getMetadata(
+      payload.execution.worker.id,
+      payload.execution.worker.version
+    );
+    if (!this._taskRunProcess) {
+      const taskRunProcess = new TaskRunProcess(
+        payload.execution,
+        this.path,
+        {
+          ...this.params.env,
+          ...payload.environment ?? {}
+        },
+        metadata,
+        this.params
+      );
+      taskRunProcess.onExit.attach(() => {
+        this._taskRunProcess = void 0;
+      });
+      taskRunProcess.onTaskHeartbeat.attach((id) => {
+        this.onTaskHeartbeat.post(id);
+      });
+      taskRunProcess.onWaitForBatch.attach((message) => {
+        this.onWaitForBatch.post(message);
+      });
+      taskRunProcess.onWaitForDuration.attach((message) => {
+        this.onWaitForDuration.post(message);
+      });
+      taskRunProcess.onWaitForTask.attach((message) => {
+        this.onWaitForTask.post(message);
+      });
+      taskRunProcess.onReadyForCheckpoint.attach((message) => {
+        this.onReadyForCheckpoint.post(message);
+      });
+      taskRunProcess.onCancelCheckpoint.attach((message) => {
+        this.onCancelCheckpoint.post(message);
+      });
+      this.preCheckpointNotification.attach((message) => {
+        taskRunProcess.preCheckpointNotification.post(message);
+      });
+      this.checkpointCanceledNotification.attach((message) => {
+        taskRunProcess.checkpointCanceledNotification.post(message);
+      });
+      await taskRunProcess.initialize();
+      this._taskRunProcess = taskRunProcess;
+    }
+    return this._taskRunProcess;
+  }
+  // We need to fork the process before we can execute any tasks
+  async executeTaskRun(payload) {
+    try {
+      const taskRunProcess = await this.#initializeTaskRunProcess(payload);
+      const result = await taskRunProcess.executeTaskRun(payload);
+      if (result.ok) {
+        return result;
+      }
+      const error = result.error;
+      if (error.type === "BUILT_IN_ERROR") {
+        const mappedError = await this.#correctError(error, payload.execution);
+        return {
+          ...result,
+          error: mappedError
+        };
+      }
+      return result;
+    } catch (e) {
+      if (e instanceof CancelledProcessError) {
+        return {
+          id: payload.execution.attempt.id,
+          ok: false,
+          retry: void 0,
+          error: {
+            type: "INTERNAL_ERROR",
+            code: TaskRunErrorCodes.TASK_RUN_CANCELLED
+          }
+        };
+      }
+      if (e instanceof CleanupProcessError) {
+        return {
+          id: payload.execution.attempt.id,
+          ok: false,
+          retry: void 0,
+          error: {
+            type: "INTERNAL_ERROR",
+            code: TaskRunErrorCodes.TASK_EXECUTION_ABORTED
+          }
+        };
+      }
+      if (e instanceof UnexpectedExitError) {
+        return {
+          id: payload.execution.attempt.id,
+          ok: false,
+          retry: void 0,
+          error: {
+            type: "INTERNAL_ERROR",
+            code: TaskRunErrorCodes.TASK_PROCESS_EXITED_WITH_NON_ZERO_CODE
+          }
+        };
+      }
+      return {
+        id: payload.execution.attempt.id,
+        ok: false,
+        retry: void 0,
+        error: {
+          type: "INTERNAL_ERROR",
+          code: TaskRunErrorCodes.TASK_EXECUTION_FAILED
+        }
+      };
+    }
+  }
+  async cancelAttempt(attemptId) {
+    await this._taskRunProcess?.cancel();
+  }
+  async #correctError(error, execution) {
+    return {
+      ...error,
+      stackTrace: correctErrorStackTrace(error.stackTrace, this.params.projectConfig.projectDir)
+    };
+  }
+};
+var TaskRunProcess = class {
+  constructor(execution, path, env, metadata, worker) {
+    this.execution = execution;
+    this.path = path;
+    this.env = env;
+    this.metadata = metadata;
+    this.worker = worker;
+  }
+  _ipc;
+  _child;
+  _attemptPromises = /* @__PURE__ */ new Map();
+  _attemptStatuses = /* @__PURE__ */ new Map();
+  _currentExecution;
+  _isBeingKilled = false;
+  _isBeingCancelled = false;
+  onTaskHeartbeat = new Evt();
+  onExit = new Evt();
+  onWaitForBatch = new Evt();
+  onWaitForDuration = new Evt();
+  onWaitForTask = new Evt();
+  preCheckpointNotification = Evt.create();
+  checkpointCanceledNotification = Evt.create();
+  onReadyForCheckpoint = Evt.create();
+  onCancelCheckpoint = Evt.create();
+  async initialize() {
+    this._child = fork(this.path, {
+      stdio: [
+        /*stdin*/
+        "ignore",
+        /*stdout*/
+        "pipe",
+        /*stderr*/
+        "pipe",
+        "ipc"
+      ],
+      env: {
+        ...this.execution.run.isTest ? { TRIGGER_LOG_LEVEL: "debug" } : {},
+        ...this.env,
+        OTEL_RESOURCE_ATTRIBUTES: JSON.stringify({
+          [SemanticInternalAttributes.PROJECT_DIR]: this.worker.projectConfig.projectDir
+        }),
+        ...this.worker.debugOtel ? { OTEL_LOG_LEVEL: "debug" } : {}
+      }
+    });
+    this._ipc = new ZodIpcConnection({
+      listenSchema: ProdChildToWorkerMessages,
+      emitSchema: ProdWorkerToChildMessages,
+      process: this._child,
+      handlers: {
+        TASK_RUN_COMPLETED: async (message) => {
+          const { result, execution } = message;
+          const promiseStatus = this._attemptStatuses.get(execution.attempt.id);
+          if (promiseStatus !== "PENDING") {
+            return;
+          }
+          this._attemptStatuses.set(execution.attempt.id, "RESOLVED");
+          const attemptPromise = this._attemptPromises.get(execution.attempt.id);
+          if (!attemptPromise) {
+            return;
+          }
+          const { resolver } = attemptPromise;
+          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);
+          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
+            };
+          }
+        }
+      }
+    });
+    this._child.on("exit", this.#handleExit.bind(this));
+    this._child.stdout?.on("data", this.#handleLog.bind(this));
+    this._child.stderr?.on("data", this.#handleStdErr.bind(this));
+  }
+  async cancel() {
+    this._isBeingCancelled = true;
+    await this.cleanup(true);
+  }
+  async cleanup(kill = false) {
+    if (kill && this._isBeingKilled) {
+      return;
+    }
+    this._isBeingKilled = kill;
+    await this._ipc?.sendWithAck("CLEANUP", {
+      flush: true,
+      kill
+    });
+  }
+  async executeTaskRun(payload) {
+    let resolver;
+    let rejecter;
+    const promise = new Promise((resolve, reject) => {
+      resolver = resolve;
+      rejecter = reject;
+    });
+    this._attemptStatuses.set(payload.execution.attempt.id, "PENDING");
+    this._attemptPromises.set(payload.execution.attempt.id, { resolver, rejecter });
+    const { execution, traceContext } = payload;
+    this._currentExecution = execution;
+    if (this._child?.connected && !this._isBeingKilled && !this._child.killed) {
+      await this._ipc?.send("EXECUTE_TASK_RUN", {
+        execution,
+        traceContext,
+        metadata: this.metadata
+      });
+    }
+    const result = await promise;
+    this._currentExecution = void 0;
+    return result;
+  }
+  taskRunCompletedNotification(completion, execution) {
+    if (!completion.ok && typeof completion.retry !== "undefined") {
+      return;
+    }
+    if (this._child?.connected && !this._isBeingKilled && !this._child.killed) {
+      this._ipc?.send("TASK_RUN_COMPLETED_NOTIFICATION", {
+        completion,
+        execution
+      });
+    }
+  }
+  waitCompletedNotification() {
+    if (this._child?.connected && !this._isBeingKilled && !this._child.killed) {
+      this._ipc?.send("WAIT_COMPLETED_NOTIFICATION", {});
+    }
+  }
+  async #handleExit(code) {
+    for (const [id, status] of this._attemptStatuses.entries()) {
+      if (status === "PENDING") {
+        this._attemptStatuses.set(id, "REJECTED");
+        const attemptPromise = this._attemptPromises.get(id);
+        if (!attemptPromise) {
+          continue;
+        }
+        const { rejecter } = attemptPromise;
+        if (this._isBeingCancelled) {
+          rejecter(new CancelledProcessError());
+        } else if (this._isBeingKilled) {
+          rejecter(new CleanupProcessError());
+        } else {
+          rejecter(new UnexpectedExitError(code));
+        }
+      }
+    }
+    this.onExit.post(code);
+  }
+  #handleLog(data) {
+    if (!this._currentExecution) {
+      return;
+    }
+    console.log(
+      `[${this.metadata.version}][${this._currentExecution.run.id}.${this._currentExecution.attempt.number}] ${data.toString()}`
+    );
+  }
+  #handleStdErr(data) {
+    if (this._isBeingKilled) {
+      return;
+    }
+    if (!this._currentExecution) {
+      console.error(`[${this.metadata.version}] ${data.toString()}`);
+      return;
+    }
+    console.error(
+      `[${this.metadata.version}][${this._currentExecution.run.id}.${this._currentExecution.attempt.number}] ${data.toString()}`
+    );
+  }
+  #kill() {
+    if (this._child && !this._child.killed) {
+      this._child?.kill();
+    }
+  }
+};
+
+// src/workers/prod/entry-point.ts
+import { setTimeout as setTimeout2 } from "node:timers/promises";
+var HTTP_SERVER_PORT2 = Number(process.env.HTTP_SERVER_PORT || getRandomPortNumber());
+var COORDINATOR_HOST = process.env.COORDINATOR_HOST || "127.0.0.1";
+var COORDINATOR_PORT = Number(process.env.COORDINATOR_PORT || 50080);
+var MACHINE_NAME2 = process.env.MACHINE_NAME || "local";
+var POD_NAME = process.env.POD_NAME || "some-pod";
+var SHORT_HASH = process.env.TRIGGER_CONTENT_HASH.slice(0, 9);
+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__,
+      env: {
+        ...gatherProcessEnv(),
+        TRIGGER_API_URL: this.apiUrl,
+        TRIGGER_SECRET_KEY: this.apiKey,
+        OTEL_EXPORTER_OTLP_ENDPOINT: process.env.OTEL_EXPORTER_OTLP_ENDPOINT ?? "http://0.0.0.0:4318"
+      },
+      contentHash: this.contentHash
+    });
+    this.#backgroundWorker.onTaskHeartbeat.attach((attemptFriendlyId) => {
+      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", { 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) {
+        logger2.error("Failed to send wait message, attempt friendly ID not set", { message });
+        return;
+      }
+      const { willCheckpointAndRestore } = await this.#coordinatorSocket.socket.emitWithAck(
+        "WAIT_FOR_DURATION",
+        {
+          ...message,
+          attemptFriendlyId: this.attemptFriendlyId
+        }
+      );
+      this.#prepareForWait("WAIT_FOR_DURATION", willCheckpointAndRestore);
+    });
+    this.#backgroundWorker.onWaitForTask.attach(async (message) => {
+      if (!this.attemptFriendlyId) {
+        logger2.error("Failed to send wait message, attempt friendly ID not set", { message });
+        return;
+      }
+      const { willCheckpointAndRestore } = await this.#coordinatorSocket.socket.emitWithAck(
+        "WAIT_FOR_TASK",
+        {
+          ...message,
+          attemptFriendlyId: this.attemptFriendlyId
+        }
+      );
+      this.#prepareForWait("WAIT_FOR_TASK", willCheckpointAndRestore);
+    });
+    this.#backgroundWorker.onWaitForBatch.attach(async (message) => {
+      if (!this.attemptFriendlyId) {
+        logger2.error("Failed to send wait message, attempt friendly ID not set", { message });
+        return;
+      }
+      const { willCheckpointAndRestore } = await this.#coordinatorSocket.socket.emitWithAck(
+        "WAIT_FOR_BATCH",
+        {
+          ...message,
+          attemptFriendlyId: this.attemptFriendlyId
+        }
+      );
+      this.#prepareForWait("WAIT_FOR_BATCH", willCheckpointAndRestore);
+    });
+    this.#httpPort = port;
+    this.#httpServer = this.#createHttpServer();
+  }
+  apiUrl = process.env.TRIGGER_API_URL;
+  apiKey = process.env.TRIGGER_SECRET_KEY;
+  contentHash = process.env.TRIGGER_CONTENT_HASH;
+  projectRef = process.env.TRIGGER_PROJECT_REF;
+  envId = process.env.TRIGGER_ENV_ID;
+  runId = process.env.TRIGGER_RUN_ID || "index-only";
+  deploymentId = process.env.TRIGGER_DEPLOYMENT_ID;
+  deploymentVersion = process.env.TRIGGER_DEPLOYMENT_VERSION;
+  runningInKubernetes = !!process.env.KUBERNETES_PORT;
+  executing = false;
+  completed = /* @__PURE__ */ new Set();
+  paused = false;
+  attemptFriendlyId;
+  nextResumeAfter;
+  waitForPostStart = false;
+  #httpPort;
+  #backgroundWorker;
+  #httpServer;
+  #coordinatorSocket;
+  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 (!reconnectImmediately) {
+      await setTimeout2(1e3);
+    }
+    let coordinatorHost = COORDINATOR_HOST;
+    try {
+      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 });
+    } finally {
+      this.#coordinatorSocket = this.#createCoordinatorSocket(coordinatorHost);
+    }
+  }
+  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) {
+    logger2.log("prepare for retry", { willCheckpointAndRestore, shouldExit });
+    if (shouldExit) {
+      if (willCheckpointAndRestore) {
+        logger2.log("WARNING: Will checkpoint but also requested exit. This won't end well.");
+      }
+      await this.#exitGracefully();
+    }
+    this.executing = false;
+    this.attemptFriendlyId = void 0;
+    if (willCheckpointAndRestore) {
+      this.waitForPostStart = true;
+      this.#coordinatorSocket.socket.emit("READY_FOR_CHECKPOINT", { version: "v1" });
+      return;
+    }
+  }
+  #resumeAfterDuration() {
+    this.paused = false;
+    this.nextResumeAfter = void 0;
+    this.waitForPostStart = false;
+    this.#backgroundWorker.waitCompletedNotification();
+  }
+  #returnValidatedExtraHeaders(headers) {
+    for (const [key, value] of Object.entries(headers)) {
+      if (value === void 0) {
+        throw new Error(`Extra header is undefined: ${key}`);
+      }
+    }
+    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,
+      "x-pod-name": POD_NAME,
+      "x-trigger-content-hash": this.contentHash,
+      "x-trigger-project-ref": this.projectRef,
+      "x-trigger-env-id": this.envId,
+      "x-trigger-deployment-id": this.deploymentId,
+      "x-trigger-run-id": this.runId,
+      "x-trigger-deployment-version": this.deploymentVersion
+    });
+    if (this.attemptFriendlyId) {
+      extraHeaders["x-trigger-attempt-friendly-id"] = this.attemptFriendlyId;
+    }
+    logger2.log("connecting to coordinator", {
+      host,
+      port: COORDINATOR_PORT,
+      extraHeaders
+    });
+    const coordinatorConnection = new ZodSocketConnection2({
+      namespace: "prod-worker",
+      host,
+      port: COORDINATOR_PORT,
+      clientMessages: ProdWorkerToCoordinatorMessages,
+      serverMessages: CoordinatorToProdWorkerMessages,
+      extraHeaders,
+      handlers: {
+        RESUME_AFTER_DEPENDENCY: async (message) => {
+          if (!this.paused) {
+            logger2.error("worker not paused", {
+              completions: message.completions,
+              executions: message.executions
+            });
+            return;
+          }
+          if (message.completions.length !== message.executions.length) {
+            logger2.error("did not receive the same number of completions and executions", {
+              completions: message.completions,
+              executions: message.executions
+            });
+            return;
+          }
+          if (message.completions.length === 0 || message.executions.length === 0) {
+            logger2.error("no completions or executions", {
+              completions: message.completions,
+              executions: message.executions
+            });
+            return;
+          }
+          if (this.nextResumeAfter !== "WAIT_FOR_TASK" && this.nextResumeAfter !== "WAIT_FOR_BATCH") {
+            logger2.error("not waiting to resume after dependency", {
+              nextResumeAfter: this.nextResumeAfter
+            });
+            return;
+          }
+          if (this.nextResumeAfter === "WAIT_FOR_TASK" && message.completions.length > 1) {
+            logger2.error("waiting for single task but got multiple completions", {
+              completions: message.completions,
+              executions: message.executions
+            });
+            return;
+          }
+          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];
+            if (!completion || !execution)
+              continue;
+            this.#backgroundWorker.taskRunCompletedNotification(completion, execution);
+          }
+        },
+        RESUME_AFTER_DURATION: async (message) => {
+          if (!this.paused) {
+            logger2.error("worker not paused", {
+              attemptId: message.attemptId
+            });
+            return;
+          }
+          if (this.nextResumeAfter !== "WAIT_FOR_DURATION") {
+            logger2.error("not waiting to resume after duration", {
+              nextResumeAfter: this.nextResumeAfter
+            });
+            return;
+          }
+          this.#resumeAfterDuration();
+        },
+        EXECUTE_TASK_RUN: async ({ executionPayload }) => {
+          if (this.executing) {
+            logger2.error("dropping execute request, already executing");
+            return;
+          }
+          if (this.completed.has(executionPayload.execution.attempt.id)) {
+            logger2.error("dropping execute request, already completed");
+            return;
+          }
+          this.executing = true;
+          this.attemptFriendlyId = executionPayload.execution.attempt.id;
+          const completion = await this.#backgroundWorker.executeTaskRun(executionPayload);
+          logger2.log("completed", completion);
+          this.completed.add(executionPayload.execution.attempt.id);
+          const { willCheckpointAndRestore, shouldExit } = await this.#coordinatorSocket.socket.emitWithAck("TASK_RUN_COMPLETED", {
+            version: "v1",
+            execution: executionPayload.execution,
+            completion
+          });
+          logger2.log("completion acknowledged", { willCheckpointAndRestore, shouldExit });
+          this.#prepareForRetry(willCheckpointAndRestore, shouldExit);
+        },
+        REQUEST_ATTEMPT_CANCELLATION: async (message) => {
+          if (!this.executing) {
+            return;
+          }
+          await this.#backgroundWorker.cancelAttempt(message.attemptId);
+        },
+        REQUEST_EXIT: async () => {
+          this.#coordinatorSocket.close();
+          process.exit(0);
+        },
+        READY_FOR_RETRY: async (message) => {
+          if (this.completed.size < 1) {
+            return;
+          }
+          this.#coordinatorSocket.socket.emit("READY_FOR_EXECUTION", {
+            version: "v1",
+            runId: this.runId,
+            totalCompletions: this.completed.size
+          });
+        }
+      },
+      onConnection: async (socket, handler, sender, logger3) => {
+        if (this.waitForPostStart) {
+          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();
+            const { success } = await socket.emitWithAck("INDEX_TASKS", {
+              version: "v1",
+              deploymentId: this.deploymentId,
+              ...taskResources
+            });
+            if (success) {
+              logger3.info("indexing done, shutting down..");
+              process.exit(0);
+            } else {
+              logger3.info("indexing failure, shutting down..");
+              process.exit(1);
+            }
+          } catch (e) {
+            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: "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) {
+              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
+              });
+            } else if (typeof e === "string") {
+              logger3.error("string error", { error: { message: e } });
+              socket.emit("INDEXING_FAILED", {
+                version: "v1",
+                deploymentId: this.deploymentId,
+                error: {
+                  name: "Error",
+                  message: e
+                }
+              });
+            } else {
+              logger3.error("unknown error", { error: e });
+              socket.emit("INDEXING_FAILED", {
+                version: "v1",
+                deploymentId: this.deploymentId,
+                error: {
+                  name: "Error",
+                  message: "Unknown error"
+                }
+              });
+            }
+            await setTimeout2(200);
+            process.exit(111);
+          }
+        }
+        if (this.executing) {
+          return;
+        }
+        socket.emit("READY_FOR_EXECUTION", {
+          version: "v1",
+          runId: this.runId,
+          totalCompletions: this.completed.size
+        });
+      },
+      onError: async (socket, err, logger3) => {
+        logger3.error("onError", {
+          error: {
+            name: err.name,
+            message: err.message
+          }
+        });
+        await this.#reconnect();
+      },
+      onDisconnect: async (socket, reason, description, logger3) => {
+      }
+    });
+    return coordinatorConnection;
+  }
+  #createHttpServer() {
+    const httpServer = createServer(async (req, res) => {
+      logger2.log(`[${req.method}]`, req.url);
+      const reply = new HttpReply(res);
+      try {
+        const url = new URL(req.url ?? "", `http://${req.headers.host}`);
+        switch (url.pathname) {
+          case "/health": {
+            return reply.text("ok");
+          }
+          case "/status": {
+            return reply.json({
+              executing: this.executing,
+              paused: this.paused,
+              completed: this.completed.size,
+              nextResumeAfter: this.nextResumeAfter
+            });
+          }
+          case "/connect": {
+            this.#coordinatorSocket.connect();
+            return reply.text("Connected to coordinator");
+          }
+          case "/close": {
+            await this.#coordinatorSocket.sendWithAck("LOG", {
+              version: "v1",
+              text: `[${req.method}] ${req.url}`
+            });
+            this.#coordinatorSocket.close();
+            return reply.text("Disconnected from coordinator");
+          }
+          case "/test": {
+            await this.#coordinatorSocket.sendWithAck("LOG", {
+              version: "v1",
+              text: `[${req.method}] ${req.url}`
+            });
+            return reply.text("Received ACK from coordinator");
+          }
+          case "/preStop": {
+            const cause = PreStopCauses.safeParse(url.searchParams.get("cause"));
+            if (!cause.success) {
+              logger2.error("Failed to parse cause", { cause });
+              return reply.text("Failed to parse cause", 400);
+            }
+            switch (cause.data) {
+              case "terminate": {
+                break;
+              }
+              default: {
+                logger2.error("Unhandled cause", { cause: cause.data });
+                break;
+              }
+            }
+            return reply.text("preStop ok");
+          }
+          case "/postStart": {
+            const cause = PostStartCauses.safeParse(url.searchParams.get("cause"));
+            if (!cause.success) {
+              logger2.error("Failed to parse cause", { cause });
+              return reply.text("Failed to parse cause", 400);
+            }
+            switch (cause.data) {
+              case "index": {
+                break;
+              }
+              case "create": {
+                break;
+              }
+              case "restore": {
+                await this.#reconnect(true, true);
+                break;
+              }
+              default: {
+                logger2.error("Unhandled cause", { cause: cause.data });
+                break;
+              }
+            }
+            return reply.text("postStart ok");
+          }
+          default: {
+            return reply.empty(404);
+          }
+        }
+      } catch (error) {
+        logger2.error("HTTP server error", { error });
+        reply.empty(500);
+      }
+    });
+    httpServer.on("clientError", (err, socket) => {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    });
+    httpServer.on("listening", () => {
+      logger2.log("http server listening on port", this.#httpPort);
+    });
+    httpServer.on("error", async (error) => {
+      if (error.code != "EADDRINUSE") {
+        return;
+      }
+      logger2.error(`port ${this.#httpPort} already in use, retrying with random port..`);
+      this.#httpPort = getRandomPortNumber();
+      await setTimeout2(100);
+      this.start();
+    });
+    return httpServer;
+  }
+  async #initializeWorker() {
+    const envVars = await this.#fetchEnvironmentVariables();
+    await this.#backgroundWorker.initialize({ env: envVars });
+    let packageVersion;
+    const taskResources = [];
+    if (!this.#backgroundWorker.tasks) {
+      throw new Error(`Background Worker started without tasks`);
+    }
+    for (const task of this.#backgroundWorker.tasks) {
+      taskResources.push(task);
+      packageVersion = task.packageVersion;
+    }
+    if (!packageVersion) {
+      throw new Error(`Background Worker started without package version`);
+    }
+    return {
+      packageVersion,
+      tasks: taskResources
+    };
+  }
+  async #fetchEnvironmentVariables() {
+    const response = await fetch(`${this.apiUrl}/api/v1/projects/${this.projectRef}/envvars`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`
+      }
+    });
+    if (!response.ok) {
+      return {};
+    }
+    const data = await response.json();
+    return data?.variables ?? {};
+  }
+  start() {
+    this.#httpServer.listen(this.#httpPort, this.host);
+  }
+};
+var prodWorker = new ProdWorker(HTTP_SERVER_PORT2);
+prodWorker.start();
+function gatherProcessEnv() {
+  const env = {
+    NODE_ENV: process.env.NODE_ENV ?? "production",
+    PATH: process.env.PATH,
+    USER: process.env.USER,
+    SHELL: process.env.SHELL,
+    LANG: process.env.LANG,
+    TERM: process.env.TERM,
+    NODE_PATH: process.env.NODE_PATH,
+    HOME: process.env.HOME
+  };
+  return Object.fromEntries(Object.entries(env).filter(([key, value]) => value !== void 0));
+}