@systemfsoftware/trigger.dev/dist/workers/dev/worker-facade.js

A Command-Line Interface for Trigger.dev (v3) projects

// src/workers/dev/worker-facade.ts
import {
  clock,
  taskCatalog
} from "@systemfsoftware/trigger.dev_core/v3";
import {
  TaskExecutor,
  DurableClock,
  getEnvVar,
  logLevels,
  OtelTaskLogger,
  ConsoleInterceptor,
  usage,
  DevUsageManager
} from "@systemfsoftware/trigger.dev_core/v3/workers";
import {
  TaskRunErrorCodes,
  TriggerTracer,
  logger,
  runtime,
  workerToChildMessages
} from "@systemfsoftware/trigger.dev_core/v3";
import { DevRuntimeManager } from "@systemfsoftware/trigger.dev_core/v3/dev";
import {
  ZodMessageHandler,
  ZodSchemaParsedError
} from "@systemfsoftware/trigger.dev_core/v3/zodMessageHandler";
__WORKER_SETUP__;
__IMPORTED_PROJECT_CONFIG__;
var durableClock = new DurableClock();
clock.setGlobalClock(durableClock);
usage.setGlobalUsageManager(new DevUsageManager());
var tracer = new TriggerTracer({ tracer: otelTracer, logger: otelLogger });
var consoleInterceptor = new ConsoleInterceptor(
  otelLogger,
  typeof __PROJECT_CONFIG__.enableConsoleLogging === "boolean" ? __PROJECT_CONFIG__.enableConsoleLogging : true
);
var devRuntimeManager = new DevRuntimeManager();
runtime.setGlobalRuntimeManager(devRuntimeManager);
var triggerLogLevel = getEnvVar("TRIGGER_LOG_LEVEL");
var configLogLevel = triggerLogLevel ? triggerLogLevel : importedConfig ? importedConfig.logLevel : __PROJECT_CONFIG__.logLevel;
var otelTaskLogger = new OtelTaskLogger({
  logger: otelLogger,
  tracer,
  level: logLevels.includes(configLogLevel) ? configLogLevel : "info"
});
logger.setGlobalTaskLogger(otelTaskLogger);
var TaskFileImports = {};
var TaskFiles = {};
__TASKS__;
(() => {
  for (const [importName, taskFile] of Object.entries(TaskFiles)) {
    const fileImports = TaskFileImports[importName];
    for (const [exportName, task] of Object.entries(fileImports ?? {})) {
      if (typeof task === "object" && task !== null && "id" in task && typeof task.id === "string") {
        if (taskCatalog.taskExists(task.id)) {
          taskCatalog.registerTaskFileMetadata(task.id, {
            exportName,
            filePath: taskFile.filePath
          });
        }
      }
    }
  }
})();
var _execution;
var _isRunning = false;
var handler = new ZodMessageHandler({
  schema: workerToChildMessages,
  messages: {
    EXECUTE_TASK_RUN: async ({ execution, traceContext, metadata }) => {
      if (_isRunning) {
        console.error("Worker is already running a task");
        await sender.send("TASK_RUN_COMPLETED", {
          execution,
          result: {
            ok: false,
            id: execution.run.id,
            error: {
              type: "INTERNAL_ERROR",
              code: TaskRunErrorCodes.TASK_ALREADY_RUNNING
            },
            usage: {
              durationMs: 0
            }
          }
        });
        return;
      }
      process.title = `trigger-dev-worker: ${execution.task.id} ${execution.run.id}`;
      const task = taskCatalog.getTask(execution.task.id);
      if (!task) {
        console.error(`Could not find task ${execution.task.id}`);
        await sender.send("TASK_RUN_COMPLETED", {
          execution,
          result: {
            ok: false,
            id: execution.run.id,
            error: {
              type: "INTERNAL_ERROR",
              code: TaskRunErrorCodes.COULD_NOT_FIND_EXECUTOR
            },
            usage: {
              durationMs: 0
            }
          }
        });
        return;
      }
      const executor = new TaskExecutor(task, {
        tracer,
        tracingSDK,
        consoleInterceptor,
        projectConfig: __PROJECT_CONFIG__,
        importedConfig,
        handleErrorFn: handleError
      });
      try {
        _execution = execution;
        _isRunning = true;
        const measurement = usage.start();
        const { result } = await executor.execute(execution, metadata, traceContext, measurement);
        const usageSample = usage.stop(measurement);
        return sender.send("TASK_RUN_COMPLETED", {
          execution,
          result: {
            ...result,
            usage: {
              durationMs: usageSample.cpuTime
            }
          }
        });
      } finally {
        _execution = void 0;
        _isRunning = false;
      }
    },
    TASK_RUN_COMPLETED_NOTIFICATION: async (payload) => {
      switch (payload.version) {
        case "v1": {
          devRuntimeManager.resumeTask(payload.completion, payload.execution.run.id);
          break;
        }
        case "v2": {
          devRuntimeManager.resumeTask(payload.completion, payload.completion.id);
          break;
        }
      }
    },
    CLEANUP: async ({ flush, kill }) => {
      if (kill) {
        await tracingSDK.flush();
        await sender.send("READY_TO_DISPOSE", void 0);
      } else {
        if (flush) {
          await tracingSDK.flush();
        }
      }
    }
  }
});
process.on("message", async (msg) => {
  await handler.handleMessage(msg);
});
var TASK_METADATA = taskCatalog.getAllTaskMetadata();
sender.send("TASKS_READY", { tasks: TASK_METADATA }).catch((err) => {
  if (err instanceof ZodSchemaParsedError) {
    sender.send("TASKS_FAILED_TO_PARSE", { zodIssues: err.error.issues, tasks: TASK_METADATA });
  } else {
    console.error("Failed to send TASKS_READY message", err);
  }
});
process.title = "trigger-dev-worker";
async function asyncHeartbeat(initialDelayInSeconds = 30, intervalInSeconds = 30) {
  async function _doHeartbeat() {
    while (true) {
      if (_isRunning && _execution) {
        try {
          await sender.send("TASK_HEARTBEAT", { id: _execution.attempt.id });
        } catch (err) {
          console.error("Failed to send HEARTBEAT message", err);
        }
      }
      await new Promise((resolve) => setTimeout(resolve, 1e3 * intervalInSeconds));
    }
  }
  await new Promise((resolve) => setTimeout(resolve, 1e3 * initialDelayInSeconds));
  return _doHeartbeat();
}
asyncHeartbeat().catch((err) => {
  console.error("Failed to start asyncHeartbeat", err);
});