trigger.dev 0.0.0-prerelease-20240219135254 → 0.0.0-v3-canary-20240321115026

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

@@ -0,0 +1,942 @@
+// src/workers/prod/entry-point.ts
+import {
+  CoordinatorToProdWorkerMessages,
+  ProdWorkerToCoordinatorMessages,
+  ZodSocketConnection as ZodSocketConnection2
+} from "@trigger.dev/core/v3";
+
+// ../core-apps/src/http.ts
+var getTextBody = (req) => new Promise((resolve) => {
+  let body = "";
+  req.on("readable", () => {
+    const chunk = req.read();
+    if (chunk) {
+      body += chunk;
+    }
+  });
+  req.on("end", () => {
+    resolve(body);
+  });
+});
+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}
+`);
+  }
+};
+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 logger = new SimpleLogger(`[${MACHINE_NAME}]`);
+
+// src/workers/prod/entry-point.ts
+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";
+  }
+};
+
+// 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();
+  onWaitForDuration = new Evt();
+  onWaitForTask = new Evt();
+  onWaitForBatch = new Evt();
+  preCheckpointNotification = 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();
+            }
+          }
+        }
+      });
+      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(
+        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);
+      });
+      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);
+      await taskRunProcess.cleanup(result.ok || result.retry === void 0);
+      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(path, env, metadata, worker) {
+    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();
+  async initialize() {
+    this._child = fork(this.path, {
+      stdio: [
+        /*stdin*/
+        "ignore",
+        /*stdout*/
+        "pipe",
+        /*stderr*/
+        "pipe",
+        "ipc"
+      ],
+      env: {
+        ...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) => {
+        },
+        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);
+        }
+      }
+    });
+    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
+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();
+    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.onWaitForDuration.attach(async (message) => {
+      const { willCheckpointAndRestore } = await this.#coordinatorSocket.socket.emitWithAck(
+        "WAIT_FOR_DURATION",
+        { version: "v1", ...message }
+      );
+      logger2.log("WAIT_FOR_DURATION", { willCheckpointAndRestore });
+      this.#backgroundWorker.preCheckpointNotification.post({ willCheckpointAndRestore });
+      setTimeout(() => {
+        if (willCheckpointAndRestore) {
+          this.paused = true;
+          this.nextResumeAfter = "WAIT_FOR_DURATION";
+        }
+        this.#coordinatorSocket.close();
+        this.#coordinatorSocket.connect();
+      }, 3e3);
+    });
+    this.#backgroundWorker.onWaitForTask.attach(async (message) => {
+      const { willCheckpointAndRestore } = await this.#coordinatorSocket.socket.emitWithAck(
+        "WAIT_FOR_TASK",
+        { version: "v1", ...message }
+      );
+      logger2.log("WAIT_FOR_TASK", { willCheckpointAndRestore });
+      this.#backgroundWorker.preCheckpointNotification.post({ willCheckpointAndRestore });
+      setTimeout(() => {
+        if (willCheckpointAndRestore) {
+          this.paused = true;
+          this.nextResumeAfter = "WAIT_FOR_TASK";
+        }
+        this.#coordinatorSocket.close();
+        this.#coordinatorSocket.connect();
+      }, 3e3);
+    });
+    this.#backgroundWorker.onWaitForBatch.attach(async (message) => {
+      const { willCheckpointAndRestore } = await this.#coordinatorSocket.socket.emitWithAck(
+        "WAIT_FOR_BATCH",
+        { version: "v1", ...message }
+      );
+      logger2.log("WAIT_FOR_BATCH", { willCheckpointAndRestore });
+      this.#backgroundWorker.preCheckpointNotification.post({ willCheckpointAndRestore });
+      setTimeout(() => {
+        if (willCheckpointAndRestore) {
+          this.paused = true;
+          this.nextResumeAfter = "WAIT_FOR_BATCH";
+        }
+        this.#coordinatorSocket.close();
+        this.#coordinatorSocket.connect();
+      }, 3e3);
+    });
+    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";
+  attemptId = process.env.TRIGGER_ATTEMPT_ID || "index-only";
+  deploymentId = process.env.TRIGGER_DEPLOYMENT_ID;
+  executing = false;
+  completed = /* @__PURE__ */ new Set();
+  paused = false;
+  nextResumeAfter;
+  #httpPort;
+  #backgroundWorker;
+  #httpServer;
+  #coordinatorSocket;
+  #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() {
+    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-attempt-id": this.attemptId,
+      "x-trigger-env-id": this.envId,
+      "x-trigger-deployment-id": this.deploymentId,
+      "x-trigger-run-id": this.runId
+    });
+    logger2.log("connecting to coordinator", {
+      host: COORDINATOR_HOST,
+      port: COORDINATOR_PORT,
+      extraHeaders
+    });
+    const coordinatorConnection = new ZodSocketConnection2({
+      namespace: "prod-worker",
+      host: COORDINATOR_HOST,
+      port: COORDINATOR_PORT,
+      clientMessages: ProdWorkerToCoordinatorMessages,
+      serverMessages: CoordinatorToProdWorkerMessages,
+      extraHeaders,
+      handlers: {
+        RESUME: async (message) => {
+          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) => {
+          this.#backgroundWorker.waitCompletedNotification();
+        },
+        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;
+          const completion = await this.#backgroundWorker.executeTaskRun(executionPayload);
+          logger2.log("completed", completion);
+          this.completed.add(executionPayload.execution.attempt.id);
+          this.executing = false;
+          await this.#backgroundWorker.flushTelemetry();
+          const { didCheckpoint, shouldExit } = await this.#coordinatorSocket.socket.emitWithAck(
+            "TASK_RUN_COMPLETED",
+            {
+              version: "v1",
+              execution: executionPayload.execution,
+              completion
+            }
+          );
+          logger2.log("completion acknowledged", { didCheckpoint, shouldExit });
+          if (shouldExit) {
+            await this.#backgroundWorker.close();
+            process.exit(0);
+          }
+          this.#coordinatorSocket.close();
+          this.#coordinatorSocket.connect();
+        },
+        REQUEST_ATTEMPT_CANCELLATION: async (message) => {
+          if (!this.executing) {
+            return;
+          }
+          await this.#backgroundWorker.cancelAttempt(message.attemptId);
+        },
+        REQUEST_EXIT: async () => {
+          process.exit(0);
+        }
+      },
+      onConnection: async (socket, handler, sender, logger3) => {
+        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("indexing done, shutting down..");
+              process.exit(0);
+            } else {
+              logger3("indexing failure, shutting down..");
+              process.exit(1);
+            }
+          } catch (e) {
+            if (e instanceof UncaughtExceptionError) {
+              logger3("uncaught exception", 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", 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("string error", e);
+              socket.emit("INDEXING_FAILED", {
+                version: "v1",
+                deploymentId: this.deploymentId,
+                error: {
+                  name: "Error",
+                  message: e
+                }
+              });
+            } else {
+              logger3("unknown error", e);
+              socket.emit("INDEXING_FAILED", {
+                version: "v1",
+                deploymentId: this.deploymentId,
+                error: {
+                  name: "Error",
+                  message: "Unknown error"
+                }
+              });
+            }
+            setTimeout(() => {
+              process.exit(1);
+            }, 200);
+          }
+        }
+        if (this.paused) {
+          if (!this.nextResumeAfter) {
+            return;
+          }
+          socket.emit("READY_FOR_RESUME", {
+            version: "v1",
+            attemptId: this.attemptId,
+            type: this.nextResumeAfter
+          });
+          this.#backgroundWorker.waitCompletedNotification();
+          this.paused = false;
+          return;
+        }
+        if (this.executing) {
+          return;
+        }
+        socket.emit("READY_FOR_EXECUTION", {
+          version: "v1",
+          attemptId: this.attemptId,
+          runId: this.runId
+        });
+      }
+    });
+    return coordinatorConnection;
+  }
+  #createHttpServer() {
+    const httpServer = createServer(async (req, res) => {
+      logger2.log(`[${req.method}]`, req.url);
+      const reply = new HttpReply(res);
+      switch (req.url) {
+        case "/complete":
+          setTimeout(() => process.exit(0), 1e3);
+          return reply.text("ok");
+        case "/date":
+          const date = /* @__PURE__ */ new Date();
+          return reply.text(date.toString());
+        case "/fail":
+          setTimeout(() => process.exit(1), 1e3);
+          return reply.text("ok");
+        case "/health":
+          return reply.text("ok");
+        case "/whoami":
+          return reply.text(this.contentHash);
+        case "/wait":
+          const { willCheckpointAndRestore } = await this.#coordinatorSocket.sendWithAck(
+            "WAIT_FOR_DURATION",
+            {
+              version: "v1",
+              ms: 6e4
+            }
+          );
+          logger2.log("WAIT_FOR_DURATION", { willCheckpointAndRestore });
+          this.#coordinatorSocket.close();
+          return reply.text("sent WAIT");
+        case "/connect":
+          this.#coordinatorSocket.connect();
+          return reply.empty();
+        case "/close":
+          this.#coordinatorSocket.sendWithAck("LOG", {
+            version: "v1",
+            text: "close without delay"
+          });
+          this.#coordinatorSocket.close();
+          return reply.empty();
+        case "/close-delay":
+          this.#coordinatorSocket.sendWithAck("LOG", {
+            version: "v1",
+            text: "close with delay"
+          });
+          setTimeout(() => {
+            this.#coordinatorSocket.close();
+          }, 200);
+          return reply.empty();
+        case "/log":
+          this.#coordinatorSocket.sendWithAck("LOG", {
+            version: "v1",
+            text: await getTextBody(req)
+          });
+          return reply.empty();
+        case "/preStop":
+          logger2.log("should do preStop stuff, e.g. checkpoint and graceful shutdown");
+          return reply.text("got preStop request");
+        case "/ready":
+          this.#coordinatorSocket.send("READY_FOR_EXECUTION", {
+            version: "v1",
+            attemptId: this.attemptId,
+            runId: this.runId
+          });
+          return reply.empty();
+        default:
+          return reply.empty(404);
+      }
+    });
+    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", (error) => {
+      if (error.code != "EADDRINUSE") {
+        return;
+      }
+      logger2.error(`port ${this.#httpPort} already in use, retrying with random port..`);
+      this.#httpPort = getRandomPortNumber();
+      setTimeout(() => {
+        this.start();
+      }, 100);
+    });
+    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({
+        id: task.id,
+        filePath: task.filePath,
+        exportName: task.exportName
+      });
+      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));
+}