trigger.dev 3.0.0-beta.8 → 3.0.0

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

@@ -1,1146 +0,0 @@
-// src/workers/prod/entry-point.ts
-import {
-  CoordinatorToProdWorkerMessages,
-  PostStartCauses,
-  PreStopCauses,
-  ProdWorkerToCoordinatorMessages,
-  ZodSocketConnection as ZodSocketConnection2
-} from "@trigger.dev/core/v3";
-
-// ../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,
-  ZodMessageSender,
-  ZodSocketConnection
-} from "@trigger.dev/core/v3";
-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,
-  ZodIpcConnection,
-  correctErrorStackTrace
-} from "@trigger.dev/core/v3";
-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();
-  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);
-      });
-      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();
-  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_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);
-        },
-        READY_FOR_CHECKPOINT: async (message) => {
-          this.onReadyForCheckpoint.post(message);
-        },
-        CANCEL_CHECKPOINT: async (message) => {
-          this.onCancelCheckpoint.post(message);
-        }
-      }
-    });
-    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;
-    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) => {
-      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" });
-    });
-    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 #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);
-    }
-  }
-  #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;
-    }
-  }
-  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.#backgroundWorker.close();
-      process.exit(0);
-    }
-    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.#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;
-  }
-  #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;
-          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 (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", { message: 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) {
-              logger3.error("uncaught exception", { message: e.originalError.message });
-              socket.emit("INDEXING_FAILED", {
-                version: "v1",
-                deploymentId: this.deploymentId,
-                error: {
-                  name: e.originalError.name,
-                  message: e.originalError.message,
-                  stack: e.originalError.stack
-                }
-              });
-            } else if (e instanceof Error) {
-              logger3.error("error", { message: e.message });
-              socket.emit("INDEXING_FAILED", {
-                version: "v1",
-                deploymentId: this.deploymentId,
-                error: {
-                  name: e.name,
-                  message: e.message,
-                  stack: e.stack
-                }
-              });
-            } else if (typeof e === "string") {
-              logger3.error("string 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(1);
-          }
-        }
-        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;
-        }
-        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,
-              pause: this.paused,
-              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;
-              }
-            }
-            logger2.log("preStop", { url: req.url });
-            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));
-}